@directus/api 32.1.0 → 32.2.0

package/dist/telemetry/utils/get-settings.js

@@ -1,14 +1,30 @@
-import { toBoolean } from '@directus/utils';
+import { SettingsService } from '../../services/settings.js';
+import { getSchema } from '../../utils/get-schema.js';
 export const getSettings = async (db) => {
-    const settings = await db
-        .select('project_id', 'mcp_enabled', 'mcp_allow_deletes', 'mcp_system_prompt_enabled', 'visual_editor_urls')
-        .from('directus_settings')
-        .first();
+    const settingsService = new SettingsService({
+        knex: db,
+        schema: await getSchema({ database: db }),
+    });
+    const settings = (await settingsService.readSingleton({
+        fields: [
+            'project_id',
+            'mcp_enabled',
+            'mcp_allow_deletes',
+            'mcp_system_prompt_enabled',
+            'visual_editor_urls',
+            'ai_openai_api_key',
+            'ai_anthropic_api_key',
+            'ai_system_prompt',
+        ],
+    }));
     return {
         project_id: settings.project_id,
-        mcp_enabled: toBoolean(settings?.mcp_enabled),
-        mcp_allow_deletes: toBoolean(settings?.mcp_allow_deletes),
-        mcp_system_prompt_enabled: toBoolean(settings?.mcp_system_prompt_enabled),
-        visual_editor_urls: settings.visual_editor_urls ? JSON.parse(settings.visual_editor_urls).length : 0,
+        mcp_enabled: settings?.mcp_enabled || false,
+        mcp_allow_deletes: settings?.mcp_allow_deletes || false,
+        mcp_system_prompt_enabled: settings?.mcp_system_prompt_enabled || false,
+        visual_editor_urls: settings.visual_editor_urls?.length || 0,
+        ai_openai_api_key: Boolean(settings?.ai_openai_api_key),
+        ai_anthropic_api_key: Boolean(settings?.ai_anthropic_api_key),
+        ai_system_prompt: Boolean(settings?.ai_system_prompt),
     };
 };

package/dist/test-utils/README.md

@@ -14,21 +14,23 @@ This directory contains mock implementations for commonly used modules in servic
 - **[emitter.ts](#emitterts)** - Event emitter mocks
 - **[items-service.ts](#items-servicets)** - ItemsService mocks
 - **[fields-service.ts](#fields-servicets)** - FieldsService mocks
+- **[files-service.ts](#files-servicets)** - FilesService mocks
+- **[folders-service.ts](#folders-servicets)** - FoldersService mocks
 - **[test-helpers.ts](#test-helpersts)** - Test data factory functions
 
 ## Quick Start
 
 ```typescript
-import { createMockKnex, resetKnexMocks } from '../__mocks__/knex.js';
+import { createMockKnex, resetKnexMocks } from '../test-utils/knex.js';
 
 // Set up mocks
 vi.mock('../../src/database/index', async () => {
-	const { mockDatabase } = await import('../__mocks__/database.js');
+	const { mockDatabase } = await import('../test-utils/database.js');
 	return mockDatabase();
 });
 
 vi.mock('../cache.js', async () => {
-	const { mockCache } = await import('../__mocks__/cache.js');
+	const { mockCache } = await import('../test-utils/cache.js');
 	return mockCache();
 });
 
@@ -203,13 +205,13 @@ Creates a standard database module mock for service tests.
 ```typescript
 // Standard PostgreSQL mock
 vi.mock('../../src/database/index', async () => {
-	const { mockDatabase } = await import('../__mocks__/database.js');
+	const { mockDatabase } = await import('../test-utils/database.js');
 	return mockDatabase();
 });
 
 // MySQL-specific mock
 vi.mock('../../src/database/index', async () => {
-	const { mockDatabase } = await import('../__mocks__/database.js');
+	const { mockDatabase } = await import('../test-utils/database.js');
 	return mockDatabase('mysql');
 });
 
@@ -229,7 +231,7 @@ transaction wrapper).
 
 ```typescript
 vi.mock('../utils/transaction.js', async () => {
-	const { mockTransaction } = await import('../__mocks__/database.js');
+	const { mockTransaction } = await import('../test-utils/database.js');
 	return mockTransaction();
 });
 
@@ -269,13 +271,13 @@ mocks for vi.mock() declarations and spies for testing cache behavior.
 ```typescript
 // Standard usage for vi.mock()
 vi.mock('../cache.js', async () => {
-	const { mockCache } = await import('../__mocks__/cache.js');
+	const { mockCache } = await import('../test-utils/cache.js');
 	return mockCache();
 });
 
 // Testing cache clearing with spies
 import { getCache } from '../cache.js';
-import { mockCache } from '../__mocks__/cache.js';
+import { mockCache } from '../test-utils/cache.js';
 
 test('should clear cache after update', async () => {
 	const { spies } = mockCache();
@@ -305,7 +307,7 @@ Creates a standard schema inspector mock with tableInfo, columnInfo, primary, fo
 ```typescript
 // Standard usage
 vi.mock('@directus/schema', async () => {
-	const { mockSchema } = await import('../__mocks__/schema.js');
+	const { mockSchema } = await import('../test-utils/schema.js');
 	return mockSchema();
 });
 
@@ -340,7 +342,7 @@ Creates a standard emitter mock with emitAction, emitFilter, emitInit, and event
 ```typescript
 // Standard usage
 vi.mock('../emitter.js', async () => {
-	const { mockEmitter } = await import('../__mocks__/emitter.js');
+	const { mockEmitter } = await import('../test-utils/emitter.js');
 	return mockEmitter();
 });
 
@@ -390,7 +392,7 @@ Creates a standard ItemsService mock with all CRUD methods pre-configured with s
 ```typescript
 // Standard usage
 vi.mock('./items.js', async () => {
-	const { mockItemsService } = await import('../__mocks__/items-service.js');
+	const { mockItemsService } = await import('../test-utils/services/items-service.js');
 	return mockItemsService();
 });
 
@@ -423,6 +425,8 @@ Creates a standard FieldsService mock with common methods pre-configured.
 
 **Mocked methods:**
 
+In addition to the base `ItemsService` method the following `FieldsService` specific methods are available:
+
 - `addColumnToTable` → no-op function
 - `addColumnIndex` → resolves to undefined
 - `deleteField` → resolves to undefined
@@ -434,7 +438,7 @@ Creates a standard FieldsService mock with common methods pre-configured.
 ```typescript
 // Standard usage in CollectionsService tests
 vi.mock('./fields.js', async () => {
-  const { mockFieldsService } = await import('../__mocks__/fields-service.js');
+  const { mockFieldsService } = await import('../test-utils/services/fields-service.js');
   return mockFieldsService();
 });
 
@@ -450,43 +454,110 @@ expect(addColumnIndexSpy).toHaveBeenCalled();
 
 ---
 
+### files-service.ts
+
+Provides FilesService mocking utilities for testing services that depend on FilesService.
+
+#### `mockFilesService()`
+
+Creates a standard FilesService mock with common methods pre-configured.
+
+**Returns:** Mock module object with `FilesService` class
+
+**Mocked methods:**
+
+In addition to the base `ItemsService` method the following `FilesService` specific methods are available:
+
+- `uploadOne` → `1`
+- `importOne` → `1`
+
+**Example:**
+
+```typescript
+// Standard usage in service tests
+vi.mock('./files.js', async () => {
+	const { mockFilesService } = await import('../test-utils/services/files-service.js');
+	return mockFilesService();
+});
+
+// Override specific methods during tests
+import { FilesService } from './files.js';
+
+const uploadOneSpy = vi.spyOn(FilesService.prototype, 'uploadOne').mockResolvedValue(`1`);
+```
+
+---
+
+### folders-service.ts
+
+Provides FoldersService mocking utilities for testing services that depend on FoldersService.
+
+#### `mockFilesService()`
+
+Creates a standard FoldersService mock with common methods pre-configured.
+
+**Returns:** Mock module object with `FoldersService` class
+
+**Mocked methods:**
+
+In addition to the base `ItemsService` method the following `FoldersService` specific methods are available:
+
+- `buildTree` → return `1` => `root` map
+
+**Example:**
+
+```typescript
+// Standard usage in service tests
+vi.mock('./folders.js', async () => {
+	const { mockFoldersService } = await import('../test-utils/services/folders-service.js');
+	return mockFilesService();
+});
+
+// Override specific methods during tests
+import { FoldersService } from './folders.js';
+
+const buildTreeSpy = vi.spyOn(FoldersService.prototype, 'buildTree').mockResolvedValue(new Map('1', 'root-alt'));
+```
+
+---
+
 ## Common Patterns
 
 ### Full Service Test Setup
 
 ```typescript
-import { createMockKnex, resetKnexMocks } from '../__mocks__/knex.js';
+import { createMockKnex, resetKnexMocks } from '../test-utils/knex.js';
 import { SchemaBuilder } from '@directus/schema-builder';
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 
 // Mock all dependencies (before imports)
 vi.mock('../../src/database/index', async () => {
-	const { mockDatabase } = await import('../__mocks__/database.js');
+	const { mockDatabase } = await import('../test-utils/database.js');
 	return mockDatabase();
 });
 
 vi.mock('@directus/schema', async () => {
-	const { mockSchema } = await import('../__mocks__/schema.js');
+	const { mockSchema } = await import('../test-utils/schema.js');
 	return mockSchema();
 });
 
 vi.mock('../cache.js', async () => {
-	const { mockCache } = await import('../__mocks__/cache.js');
+	const { mockCache } = await import('../test-utils/cache.js');
 	return mockCache();
 });
 
 vi.mock('../emitter.js', async () => {
-	const { mockEmitter } = await import('../__mocks__/emitter.js');
+	const { mockEmitter } = await import('../test-utils/emitter.js');
 	return mockEmitter();
 });
 
 vi.mock('./items.js', async () => {
-	const { mockItemsService } = await import('../__mocks__/items-service.js');
+	const { mockItemsService } = await import('../test-utils/services/items-service.js');
 	return mockItemsService();
 });
 
 vi.mock('../utils/transaction.js', async () => {
-	const { mockTransaction } = await import('../__mocks__/database.js');
+	const { mockTransaction } = await import('../test-utils/database.js');
 	return mockTransaction();
 });
 
@@ -525,7 +596,7 @@ describe('Integration Tests', () => {
 ### Testing Schema Operations
 
 ```typescript
-import { mockCreateTable, mockAlterTable, createMockTableBuilder } from '../__mocks__/knex.js';
+import { mockCreateTable, mockAlterTable, createMockTableBuilder } from '../test-utils/knex.js';
 
 test('should create table with correct schema', async () => {
 	const { db, mockSchemaBuilder } = createMockKnex();
@@ -552,7 +623,7 @@ test('should alter table to add column', async () => {
 
 ```typescript
 import { getCache } from '../cache.js';
-import { mockCache } from '../__mocks__/cache.js';
+import { mockCache } from '../test-utils/cache.js';
 
 test('should clear cache after update', async () => {
 	const { spies } = mockCache();
@@ -604,7 +675,7 @@ test('should read column info', async () => {
 ### Testing with System Collection Mocks
 
 ```typescript
-import { setupSystemCollectionMocks } from '../__mocks__/knex.js';
+import { setupSystemCollectionMocks } from '../test-utils/knex.js';
 
 describe('Service Tests', () => {
 	const { db, tracker, mockSchemaBuilder } = createMockKnex();
@@ -678,7 +749,7 @@ Always declare `vi.mock()` calls **before** importing the modules they mock:
 ```typescript
 // ✅ Correct - mocks first
 vi.mock('../cache.js', async () => {
-	const { mockCache } = await import('../__mocks__/cache.js');
+	const { mockCache } = await import('../test-utils/cache.js');
 	return mockCache();
 });
 
@@ -688,7 +759,7 @@ import { YourService } from './your-service.js';
 import { YourService } from './your-service.js';
 
 vi.mock('../cache.js', async () => {
-	const { mockCache } = await import('../__mocks__/cache.js');
+	const { mockCache } = await import('../test-utils/cache.js');
 	return mockCache();
 });
 ```

package/dist/test-utils/cache.d.ts

@@ -12,13 +12,13 @@
  * ```typescript
  * // Standard usage for vi.mock()
  * vi.mock('../cache.js', async () => {
- *   const { mockCache } = await import('../__mocks__/cache.js');
+ *   const { mockCache } = await import('../test-utils/cache.js');
  *   return mockCache();
  * });
  *
  * // Testing cache clearing with spies
  * import { getCache } from '../cache.js';
- * import { mockCache } from '../__mocks__/cache.js';
+ * import { mockCache } from '../test-utils/cache.js';
  *
  * test('should clear cache after update', async () => {
  *   const { spies } = mockCache();

package/dist/test-utils/cache.js

@@ -13,13 +13,13 @@ import { vi } from 'vitest';
  * ```typescript
  * // Standard usage for vi.mock()
  * vi.mock('../cache.js', async () => {
- *   const { mockCache } = await import('../__mocks__/cache.js');
+ *   const { mockCache } = await import('../test-utils/cache.js');
  *   return mockCache();
  * });
  *
  * // Testing cache clearing with spies
  * import { getCache } from '../cache.js';
- * import { mockCache } from '../__mocks__/cache.js';
+ * import { mockCache } from '../test-utils/cache.js';
  *
  * test('should clear cache after update', async () => {
  *   const { spies } = mockCache();

package/dist/test-utils/{fields-service.d.ts → services/fields-service.d.ts}

@@ -12,7 +12,7 @@
  * ```typescript
  * // Standard usage
  * vi.mock('./fields.js', async () => {
- *   const { mockFieldsService } = await import('../__mocks__/fields-service.js');
+ *   const { mockFieldsService } = await import('../test-utils/services/fields-service.js');
  *   return mockFieldsService();
  * });
  *

package/dist/test-utils/{fields-service.js → services/fields-service.js}

@@ -3,6 +3,7 @@
  * Provides simplified mocks for src/services/fields module used in service testing
  */
 import { vi } from 'vitest';
+import { mockItemsService } from './items-service.js';
 /**
  * Creates a standard FieldsService mock for service tests
  * This matches the pattern used in CollectionsService tests
@@ -13,7 +14,7 @@ import { vi } from 'vitest';
  * ```typescript
  * // Standard usage
  * vi.mock('./fields.js', async () => {
- *   const { mockFieldsService } = await import('../__mocks__/fields-service.js');
+ *   const { mockFieldsService } = await import('../test-utils/services/fields-service.js');
  *   return mockFieldsService();
  * });
  *
@@ -25,7 +26,7 @@ import { vi } from 'vitest';
  * ```
  */
 export function mockFieldsService() {
-    const FieldsService = vi.fn();
+    const { ItemsService: FieldsService } = mockItemsService();
     // Mock common methods used by other services (like CollectionsService)
     FieldsService.prototype.addColumnToTable = vi.fn().mockImplementation(() => { });
     FieldsService.prototype.addColumnIndex = vi.fn().mockResolvedValue(undefined);

package/dist/test-utils/services/files-service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * FilesService mocking utilities for service tests
+ * Provides simplified mocks for src/services/files module used in service testing
+ */
+/**
+ * Creates a standard FilesService mock for service tests
+ * This matches the pattern used in CollectionsService tests
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./files.js', async () => {
+ *   const { mockFilesService } = await import('../test-utils/services/files-service.js');
+ *   return mockFilesService();
+ * });
+ *
+ * // To dynamically change FilesService behavior during tests:
+ * import { FilesService } from './files.js';
+ * vi.spyOn(FilesService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export declare function mockFilesService(): {
+    FilesService: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/test-utils/services/files-service.js

@@ -0,0 +1,34 @@
+/**
+ * FilesService mocking utilities for service tests
+ * Provides simplified mocks for src/services/files module used in service testing
+ */
+import { vi } from 'vitest';
+import { mockItemsService } from './items-service.js';
+/**
+ * Creates a standard FilesService mock for service tests
+ * This matches the pattern used in CollectionsService tests
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./files.js', async () => {
+ *   const { mockFilesService } = await import('../test-utils/services/files-service.js');
+ *   return mockFilesService();
+ * });
+ *
+ * // To dynamically change FilesService behavior during tests:
+ * import { FilesService } from './files.js';
+ * vi.spyOn(FilesService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export function mockFilesService() {
+    const { ItemsService: FilesService } = mockItemsService();
+    // non-crud methods
+    FilesService.prototype.uploadOne = vi.fn().mockResolvedValue(1);
+    FilesService.prototype.importOne = vi.fn().mockResolvedValue(1);
+    return { FilesService };
+}

package/dist/test-utils/services/folders-service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * FoldersService mocking utilities for service tests
+ * Provides simplified mocks for src/services/folders module used in service testing
+ */
+/**
+ * Creates a standard FoldersService mock for service tests
+ * This matches the pattern used in CollectionsService tests
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./folders.js', async () => {
+ *   const { mockFoldersService } = await import('../test-utils/services/folders-service.js');
+ *   return mockFoldersService();
+ * });
+ *
+ * // To dynamically change FoldersService behavior during tests:
+ * import { FoldersService } from './folders.js';
+ * vi.spyOn(FoldersService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export declare function mockFoldersService(): {
+    FoldersService: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/test-utils/services/folders-service.js

@@ -0,0 +1,33 @@
+/**
+ * FoldersService mocking utilities for service tests
+ * Provides simplified mocks for src/services/folders module used in service testing
+ */
+import { vi } from 'vitest';
+import { mockItemsService } from './items-service.js';
+/**
+ * Creates a standard FoldersService mock for service tests
+ * This matches the pattern used in CollectionsService tests
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./folders.js', async () => {
+ *   const { mockFoldersService } = await import('../test-utils/services/folders-service.js');
+ *   return mockFoldersService();
+ * });
+ *
+ * // To dynamically change FoldersService behavior during tests:
+ * import { FoldersService } from './folders.js';
+ * vi.spyOn(FoldersService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export function mockFoldersService() {
+    const { ItemsService: FoldersService } = mockItemsService();
+    // non-crud methods
+    FoldersService.prototype.buildTree = vi.fn().mockResolvedValue(new Map([['1', 'root']]));
+    return { FoldersService };
+}

package/dist/utils/encrypt.d.ts

@@ -0,0 +1,2 @@
+export declare const encrypt: (plainText: string, password: string) => Promise<string>;
+export declare const decrypt: (encryptedText: string, password: string) => Promise<string>;

package/dist/utils/encrypt.js

@@ -0,0 +1,64 @@
+import crypto from 'node:crypto';
+import { promisify } from 'node:util';
+const VERSION = '1';
+const KDF = 'scrypt';
+const SCRYPT_DEFAULTS = { N: 2 ** 14, r: 8, p: 1 }; // ~16MB mem, good server default
+const scryptAsync = promisify(crypto.scrypt);
+const deriveKey = async (password, salt, opts = SCRYPT_DEFAULTS) => {
+    return await scryptAsync(password, salt, 32, opts);
+};
+export const encrypt = async (plainText, password) => {
+    const salt = crypto.randomBytes(16);
+    const keyBuf = await deriveKey(password, salt, SCRYPT_DEFAULTS);
+    // Generate a 12-byte IV for GCM and keep base64 string for storage
+    const ivBuf = crypto.randomBytes(12);
+    const iv = ivBuf.toString('base64');
+    const cipher = crypto.createCipheriv('aes-256-gcm', keyBuf, ivBuf);
+    let cipherText = cipher.update(plainText, 'utf8', 'base64');
+    cipherText += cipher.final('base64');
+    const tag = cipher.getAuthTag().toString('base64');
+    // 1||scrypt||N||r||p||salt||iv||cipherText||tag
+    return [
+        VERSION,
+        KDF,
+        SCRYPT_DEFAULTS.N,
+        SCRYPT_DEFAULTS.r,
+        SCRYPT_DEFAULTS.p,
+        salt.toString('base64'),
+        iv,
+        cipherText,
+        tag,
+    ].join('||');
+};
+export const decrypt = async (encryptedText, password) => {
+    const parts = encryptedText.split('||');
+    if (parts.length < 9)
+        throw new Error('Invalid encrypted payload');
+    const [version, kdf, nStr, rStr, pStr, saltB64, ivB64, cipherText, tagB64] = parts;
+    if (version !== VERSION)
+        throw new Error(`Unsupported version: ${version}`);
+    if (kdf !== KDF)
+        throw new Error(`Unsupported kdf: ${kdf}`);
+    if (!saltB64)
+        throw new Error('No salt in encrypted string');
+    if (!ivB64)
+        throw new Error('No iv in encrypted string');
+    if (cipherText === undefined)
+        throw new Error('No cipherText in encrypted string');
+    if (!tagB64)
+        throw new Error('No tag in encrypted string');
+    const opts = {
+        N: Number(nStr) || SCRYPT_DEFAULTS.N,
+        r: Number(rStr) || SCRYPT_DEFAULTS.r,
+        p: Number(pStr) || SCRYPT_DEFAULTS.p,
+    };
+    const salt = Buffer.from(saltB64, 'base64');
+    const keyBuf = await deriveKey(password, salt, opts);
+    const iv = Buffer.from(ivB64, 'base64');
+    const tag = Buffer.from(tagB64, 'base64');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', keyBuf, iv);
+    decipher.setAuthTag(tag);
+    let plaintext = decipher.update(cipherText, 'base64', 'utf8');
+    plaintext += decipher.final('utf8');
+    return plaintext;
+};

package/dist/utils/get-accountability-for-role.js

@@ -13,13 +13,13 @@ export async function getAccountabilityForRole(role, context) {
         });
     }
     else {
-        const roles = await fetchRolesTree(role, context.database);
+        const roles = await fetchRolesTree(role, { knex: context.database });
         // The roles tree should always include the passed role. If it doesn't, it's because it
         // couldn't be read from the database and therefore doesn't exist
         if (roles.length === 0) {
             throw new Error(`Configured role "${role}" isn't a valid role ID or doesn't exist.`);
         }
-        const globalAccess = await fetchGlobalAccess({ user: null, roles, ip: context.accountability?.ip ?? null }, context.database);
+        const globalAccess = await fetchGlobalAccess({ user: null, roles, ip: context.accountability?.ip ?? null }, { knex: context.database });
         generatedAccountability = createDefaultAccountability({
             role,
             roles,

package/dist/utils/get-accountability-for-token.js

@@ -25,8 +25,8 @@ export async function getAccountabilityForToken(token, accountability) {
             if (payload.id)
                 accountability.user = payload.id;
             accountability.role = payload.role;
-            accountability.roles = await fetchRolesTree(payload.role, database);
-            const { admin, app } = await fetchGlobalAccess(accountability, database);
+            accountability.roles = await fetchRolesTree(payload.role, { knex: database });
+            const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
             accountability.admin = admin;
             accountability.app = app;
         }
@@ -44,8 +44,8 @@ export async function getAccountabilityForToken(token, accountability) {
             }
             accountability.user = user.id;
             accountability.role = user.role;
-            accountability.roles = await fetchRolesTree(user.role, database);
-            const { admin, app } = await fetchGlobalAccess(accountability, database);
+            accountability.roles = await fetchRolesTree(user.role, { knex: database });
+            const { admin, app } = await fetchGlobalAccess(accountability, { knex: database });
             accountability.admin = admin;
             accountability.app = app;
         }

package/dist/utils/get-cache-key.js

@@ -1,10 +1,10 @@
+import { ipInNetworks } from '@directus/utils/node';
+import { version } from 'directus/version';
 import hash from 'object-hash';
 import url from 'url';
 import getDatabase from '../database/index.js';
 import { fetchPoliciesIpAccess } from '../permissions/modules/fetch-policies-ip-access/fetch-policies-ip-access.js';
 import { getGraphqlQueryAndVariables } from './get-graphql-query-and-variables.js';
-import { version } from 'directus/version';
-import { ipInNetworks } from './ip-in-networks.js';
 export async function getCacheKey(req) {
     const path = url.parse(req.originalUrl).pathname;
     const isGraphQl = path?.startsWith('/graphql');

package/dist/utils/is-login-redirect-allowed.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if the defined redirect after successful SSO login is in the allow list
+ */
+export declare function isLoginRedirectAllowed(redirect: unknown, provider: string): boolean;