@directus/api 32.1.1 → 32.2.0

package/dist/services/comments.js

@@ -63,10 +63,10 @@ export class CommentsService extends ItemsService {
                 role: user['role']?.id ?? null,
                 admin: false,
                 app: false,
-                roles: await fetchRolesTree(user['role']?.id ?? null, this.knex),
+                roles: await fetchRolesTree(user['role']?.id ?? null, { knex: this.knex }),
                 ip: null,
             };
-            const userGlobalAccess = await fetchGlobalAccess(accountability, this.knex);
+            const userGlobalAccess = await fetchGlobalAccess(accountability, { knex: this.knex });
             accountability.admin = userGlobalAccess.admin;
             accountability.app = userGlobalAccess.app;
             const usersService = new UsersService({ schema: this.schema, accountability });

package/dist/services/extensions.js

@@ -109,6 +109,8 @@ export class ExtensionsService {
         await this.extensionsManager.install(versionId);
     }
     async readAll() {
+        // wait for extensions to be reloaded
+        await this.extensionsManager.isReloading();
         const settings = await this.extensionsItemService.readByQuery({ limit: -1 });
         const regular = settings.filter(({ bundle }) => bundle === null);
         const bundled = settings.filter(({ bundle }) => bundle !== null);
@@ -138,6 +140,8 @@ export class ExtensionsService {
         return output;
     }
     async readOne(id) {
+        // wait for extensions to be reloaded
+        await this.extensionsManager.isReloading();
         const meta = await this.extensionsItemService.readOne(id);
         const schema = this.extensionsManager.getExtension(meta.source, meta.folder) ?? null;
         return {

package/dist/services/folders.d.ts

@@ -1,5 +1,30 @@
-import type { AbstractServiceOptions } from '@directus/types';
+import type { AbstractServiceOptions, Folder } from '@directus/types';
 import { ItemsService } from './items.js';
-export declare class FoldersService extends ItemsService {
+export declare class FoldersService extends ItemsService<Folder> {
     constructor(options: AbstractServiceOptions);
+    /**
+     * Builds a full folder tree starting from a given root folder.
+     *
+     * This method returns a map of folder IDs to their corresponding paths
+     * relative to the root. It resolves all nested child folders and ensures
+     * that folder names are deduplicated within the same parent.
+     *
+     * Access control is applied automatically when non-admin, only folders the user has `read`
+     * access to are included.
+     *
+     * @param {string} root - The ID of the root folder to start building the tree from.
+     * @returns {Promise<Map<string, string>>} A `Map` where:
+     *   - Key: folder ID
+     *   - Value: folder path relative to the root (e.g., "Documents/Photos")
+     *
+     * @example
+     * const foldersService = new FoldersService({ schema, accountability });
+     * const tree = await foldersService.buildTree('root-folder-id');
+     * console.log(tree.get('folder1')); // e.g., "RootFolder/SubFolder1"
+     *
+     * @remarks
+     * - The returned `Map` includes the root folder itself.
+     * - If a folder has no name, its ID will be used as a fallback.
+     */
+    buildTree(root: string): Promise<Map<string, string>>;
 }

package/dist/services/folders.js

@@ -1,6 +1,81 @@
+import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
+import { NameDeduper } from './assets/name-deduper.js';
 import { ItemsService } from './items.js';
 export class FoldersService extends ItemsService {
     constructor(options) {
         super('directus_folders', options);
     }
+    /**
+     * Builds a full folder tree starting from a given root folder.
+     *
+     * This method returns a map of folder IDs to their corresponding paths
+     * relative to the root. It resolves all nested child folders and ensures
+     * that folder names are deduplicated within the same parent.
+     *
+     * Access control is applied automatically when non-admin, only folders the user has `read`
+     * access to are included.
+     *
+     * @param {string} root - The ID of the root folder to start building the tree from.
+     * @returns {Promise<Map<string, string>>} A `Map` where:
+     *   - Key: folder ID
+     *   - Value: folder path relative to the root (e.g., "Documents/Photos")
+     *
+     * @example
+     * const foldersService = new FoldersService({ schema, accountability });
+     * const tree = await foldersService.buildTree('root-folder-id');
+     * console.log(tree.get('folder1')); // e.g., "RootFolder/SubFolder1"
+     *
+     * @remarks
+     * - The returned `Map` includes the root folder itself.
+     * - If a folder has no name, its ID will be used as a fallback.
+     */
+    async buildTree(root) {
+        if (this.accountability && this.accountability.admin !== true) {
+            await validateAccess({
+                collection: 'directus_folders',
+                accountability: this.accountability,
+                action: 'read',
+                primaryKeys: [root],
+            }, {
+                knex: this.knex,
+                schema: this.schema,
+            });
+        }
+        const folders = await this.readByQuery({ limit: -1 });
+        // build folder and child lookup
+        const folderLookup = new Map();
+        const childFolderLookup = new Map();
+        for (const folder of folders) {
+            if (!folder['id'])
+                continue;
+            folderLookup.set(folder['id'], folder);
+            // root is always at the top level, we can therfor safely skip any parent references to it.
+            if (folder['parent'] && folder['id'] !== root) {
+                const children = childFolderLookup.get(folder['parent']) ?? [];
+                children.push(folder['id']);
+                childFolderLookup.set(folder['parent'], children);
+            }
+        }
+        const deduper = new NameDeduper();
+        const rootName = deduper.add(folderLookup.get(root)?.name, { fallback: root });
+        const stack = [[root, '']];
+        const tree = new Map();
+        // build tree from stack
+        while (stack.length > 0) {
+            const [folderId, path] = stack.pop() ?? [];
+            if (!folderId)
+                continue;
+            const folder = folderLookup.get(folderId);
+            if (!folder)
+                continue;
+            const children = childFolderLookup.get(folderId);
+            const folderName = deduper.add(folder['name'], { group: folder['parent'], fallback: folderId });
+            const folderPath = path === '' ? rootName : `${path}/${folderName}`;
+            tree.set(folderId, folderPath);
+            for (const childFolderId of children ?? []) {
+                stack.push([childFolderId, folderPath]);
+            }
+        }
+        return tree;
+    }
 }

package/dist/services/import-export.d.ts

@@ -1,7 +1,7 @@
 import type { AbstractServiceOptions, Accountability, DirectusError, ExportFormat, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
-import type { FunctionFieldNode, FieldNode, NestedCollectionNode } from '../types/index.js';
+import type { FieldNode, FunctionFieldNode, NestedCollectionNode } from '../types/index.js';
 export declare function createErrorTracker(): {
     addCapturedError: (err: any, rowNumber: number) => void;
     buildFinalErrors: () => DirectusError<any>[];

package/dist/services/import-export.js

@@ -1,22 +1,23 @@
 import { useEnv } from '@directus/env';
 import { createError, ErrorCode, ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
-import { parseJSON, toArray } from '@directus/utils';
+import { getDateTimeFormatted, parseJSON, toArray } from '@directus/utils';
 import { createTmpFile } from '@directus/utils/node';
 import { queue } from 'async';
 import destroyStream from 'destroy';
 import { dump as toYAML } from 'js-yaml';
 import { parse as toXML } from 'js2xmlparser';
 import { Parser as CSVParser, transforms as CSVTransforms } from 'json2csv';
+import { set } from 'lodash-es';
 import { createReadStream, createWriteStream } from 'node:fs';
 import { appendFile } from 'node:fs/promises';
 import Papa from 'papaparse';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
+import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import { useLogger } from '../logger/index.js';
 import { validateAccess } from '../permissions/modules/validate-access/validate-access.js';
-import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getService } from '../utils/get-service.js';
 import { transaction } from '../utils/transaction.js';
 import { Url } from '../utils/url.js';
@@ -24,8 +25,6 @@ import { userName } from '../utils/user-name.js';
 import { FilesService } from './files.js';
 import { NotificationsService } from './notifications.js';
 import { UsersService } from './users.js';
-import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js';
-import { set } from 'lodash-es';
 const env = useEnv();
 const logger = useLogger();
 const MAX_IMPORT_ERRORS = env['MAX_IMPORT_ERRORS'];
@@ -514,7 +513,7 @@ export class ExportService {
                 schema: this.schema,
             });
             const storage = toArray(env['STORAGE_LOCATIONS'])[0];
-            const title = `export-${collection}-${getDateFormatted()}`;
+            const title = `export-${collection}-${getDateTimeFormatted()}`;
             const filename = `${title}.${format}`;
             const fileWithDefaults = {
                 ...(options?.file ?? {}),

package/dist/services/notifications.js

@@ -29,12 +29,12 @@ export class NotificationsService extends ItemsService {
                     .addPath('admin', 'users', user['id'])
                     .toString();
                 const html = data.message ? md(data.message) : '';
-                const roles = await fetchRolesTree(user['role'], this.knex);
+                const roles = await fetchRolesTree(user['role'], { knex: this.knex });
                 const { app: app_access } = await fetchGlobalAccess({
                     user: user['id'],
                     roles,
                     ip: null,
-                }, this.knex);
+                }, { knex: this.knex });
                 const mailService = new MailService({
                     schema: this.schema,
                     knex: this.knex,

package/dist/services/payload.js

@@ -10,6 +10,8 @@ import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
 import { generateHash } from '../utils/generate-hash.js';
+import { decrypt, encrypt } from '../utils/encrypt.js';
+import { getSecret } from '../utils/get-secret.js';
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are
  * handled correctly.
@@ -124,6 +126,24 @@ export class PayloadService {
             }
             return value;
         },
+        async encrypt({ action, value, accountability }) {
+            if (!value)
+                return value;
+            if (action === 'read') {
+                // In-system calls can still get the decrypted value
+                if (accountability === null) {
+                    const key = getSecret();
+                    return await decrypt(value, key);
+                }
+                // Requests from the API entrypoints have accountability and shouldn't get the raw value
+                return '**********';
+            }
+            if (typeof value === 'string') {
+                const key = getSecret();
+                return await encrypt(value, key);
+            }
+            return value;
+        },
     };
     async processValues(action, payload, aliasMap = {}, aggregate = {}) {
         const processedPayload = toArray(payload);

package/dist/services/roles.js

@@ -3,8 +3,8 @@ import { UserIntegrityCheckFlag } from '@directus/types';
 import { clearSystemCache } from '../cache.js';
 import { fetchRolesTree } from '../permissions/lib/fetch-roles-tree.js';
 import { transaction } from '../utils/transaction.js';
-import { ItemsService } from './items.js';
 import { AccessService } from './access.js';
+import { ItemsService } from './items.js';
 import { PresetsService } from './presets.js';
 import { UsersService } from './users.js';
 export class RolesService extends ItemsService {
@@ -72,7 +72,7 @@ export class RolesService extends ItemsService {
         if (ids.includes(parent)) {
             throw new InvalidPayloadError({ reason: 'A role cannot be a parent of itself' });
         }
-        const roles = await fetchRolesTree(parent, this.knex);
+        const roles = await fetchRolesTree(parent, { knex: this.knex });
         if (ids.some((id) => roles.includes(id))) {
             // The role tree up from the parent already includes this role, so it would create a circular reference
             throw new InvalidPayloadError({ reason: 'A role cannot have a parent that is already a descendant of itself' });

package/dist/services/tus/server.js

@@ -41,7 +41,7 @@ export async function createTusServer(context) {
         datastore: store,
         locker: getTusLocker(),
         ...(RESUMABLE_UPLOADS.MAX_SIZE !== null && { maxSize: RESUMABLE_UPLOADS.MAX_SIZE }),
-        async onUploadFinish(req, upload) {
+        async onUploadFinish(_req, upload) {
             const schema = await getSchema();
             const service = new ItemsService('directus_files', {
                 schema,
@@ -92,9 +92,9 @@ export async function createTusServer(context) {
                 key: fileData.id,
                 collection: 'directus_files',
             }, {
-                database: getDatabase(),
                 schema,
-                accountability: req.accountability,
+                database: getDatabase(),
+                accountability: context.accountability ?? null,
             });
             return {
                 headers: {

package/dist/telemetry/utils/get-settings.d.ts

@@ -5,5 +5,20 @@ export type TelemetrySettings = {
     mcp_allow_deletes: boolean;
     mcp_system_prompt_enabled: boolean;
     visual_editor_urls: number;
+    ai_openai_api_key: boolean;
+    ai_anthropic_api_key: boolean;
+    ai_system_prompt: boolean;
+};
+export type DatabaseSettings = {
+    project_id: string;
+    mcp_enabled?: boolean;
+    mcp_allow_deletes?: boolean;
+    mcp_system_prompt_enabled?: boolean;
+    visual_editor_urls?: {
+        url: string;
+    }[];
+    ai_openai_api_key?: string;
+    ai_anthropic_api_key?: string;
+    ai_system_prompt?: string;
 };
 export declare const getSettings: (db: Knex) => Promise<TelemetrySettings>;

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

@@ -6,7 +6,16 @@ export const getSettings = async (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'],
+        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,
@@ -14,5 +23,8 @@ export const getSettings = async (db) => {
         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();
  * });
  *