@directus/api 31.0.0 → 32.0.0

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

@@ -0,0 +1,51 @@
+/**
+ * Cache mocking utilities for service tests
+ * Provides simplified mocks for src/cache module used in service testing
+ */
+/**
+ * Creates a standard cache mock for service tests
+ * Returns mock functions for vi.mock() and spies for testing cache behavior
+ *
+ * @returns Object with mock functions at root level and spies nested under 'spies' property
+ *
+ * @example
+ * ```typescript
+ * // Standard usage for vi.mock()
+ * vi.mock('../cache.js', async () => {
+ *   const { mockCache } = await import('../__mocks__/cache.js');
+ *   return mockCache();
+ * });
+ *
+ * // Testing cache clearing with spies
+ * import { getCache } from '../cache.js';
+ * import { mockCache } from '../__mocks__/cache.js';
+ *
+ * test('should clear cache after update', async () => {
+ *   const { spies } = mockCache();
+ *   vi.mocked(getCache).mockReturnValue(spies.mockCacheReturn as any);
+ *
+ *   const service = new YourService({ knex: db, schema });
+ *   await service.updateOne('1', { name: 'Updated' });
+ *
+ *   expect(spies.clearSpy).toHaveBeenCalled();
+ * });
+ * ```
+ */
+export declare function mockCache(): {
+    getCache: import("vitest").Mock<(...args: any[]) => any>;
+    getCacheValue: import("vitest").Mock<(...args: any[]) => any>;
+    setCacheValue: import("vitest").Mock<(...args: any[]) => any>;
+    clearSystemCache: import("vitest").Mock<(...args: any[]) => any>;
+    spies: {
+        clearSpy: import("vitest").Mock<(...args: any[]) => any>;
+        systemClearSpy: import("vitest").Mock<(...args: any[]) => any>;
+        getCacheSpy: import("vitest").Mock<(...args: any[]) => any>;
+        setCacheSpy: import("vitest").Mock<(...args: any[]) => any>;
+        mockCacheReturn: {
+            cache: any;
+            systemCache: any;
+            localSchemaCache: any;
+            lockCache: undefined;
+        };
+    };
+};

package/dist/test-utils/cache.js

@@ -0,0 +1,59 @@
+/**
+ * Cache mocking utilities for service tests
+ * Provides simplified mocks for src/cache module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard cache mock for service tests
+ * Returns mock functions for vi.mock() and spies for testing cache behavior
+ *
+ * @returns Object with mock functions at root level and spies nested under 'spies' property
+ *
+ * @example
+ * ```typescript
+ * // Standard usage for vi.mock()
+ * vi.mock('../cache.js', async () => {
+ *   const { mockCache } = await import('../__mocks__/cache.js');
+ *   return mockCache();
+ * });
+ *
+ * // Testing cache clearing with spies
+ * import { getCache } from '../cache.js';
+ * import { mockCache } from '../__mocks__/cache.js';
+ *
+ * test('should clear cache after update', async () => {
+ *   const { spies } = mockCache();
+ *   vi.mocked(getCache).mockReturnValue(spies.mockCacheReturn as any);
+ *
+ *   const service = new YourService({ knex: db, schema });
+ *   await service.updateOne('1', { name: 'Updated' });
+ *
+ *   expect(spies.clearSpy).toHaveBeenCalled();
+ * });
+ * ```
+ */
+export function mockCache() {
+    const clearSpy = vi.fn();
+    const systemClearSpy = vi.fn();
+    const getCacheSpy = vi.fn();
+    const setCacheSpy = vi.fn();
+    const mockCacheReturn = {
+        cache: { clear: clearSpy },
+        systemCache: { clear: systemClearSpy },
+        localSchemaCache: { get: getCacheSpy, set: setCacheSpy },
+        lockCache: undefined,
+    };
+    return {
+        getCache: vi.fn().mockReturnValue(mockCacheReturn),
+        getCacheValue: vi.fn().mockResolvedValue(null),
+        setCacheValue: vi.fn().mockResolvedValue(undefined),
+        clearSystemCache: vi.fn(),
+        spies: {
+            clearSpy,
+            systemClearSpy,
+            getCacheSpy,
+            setCacheSpy,
+            mockCacheReturn,
+        },
+    };
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Database mocking utilities for service tests
+ * Provides simplified mocks for src/database/index module used in service testing
+ */
+import type { DatabaseClient } from '@directus/types';
+/**
+ * Creates a standard database mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @param client Database client to mock (default: 'postgres')
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('../../src/database/index', () => mockDatabase());
+ *
+ * // For MySQL-specific tests
+ * vi.mock('../../src/database/index', () => mockDatabase('mysql'));
+ *
+ * // To dynamically change the client during tests, import and mock directly:
+ * import { getDatabaseClient } from '../database/index.js';
+ * vi.mocked(getDatabaseClient).mockReturnValue('mssql');
+ * ```
+ */
+export declare function mockDatabase(client?: DatabaseClient): {
+    default: import("vitest").Mock<(...args: any[]) => any>;
+    getDatabaseClient: import("vitest").Mock<(...args: any[]) => any>;
+    getSchemaInspector: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Creates a mock for the transaction utility
+ * By default, the mock simply executes the callback with the provided knex instance
+ * (no actual transaction wrapper, which is fine for most service tests)
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * vi.mock('../utils/transaction.js', async () => {
+ *   const { mockTransaction } = await import('../__mocks__/database.js');
+ *   return mockTransaction();
+ * });
+ * ```
+ */
+export declare function mockTransaction(): {
+    transaction: import("vitest").Mock<(knex: any, callback: any) => any>;
+};

package/dist/test-utils/database.js

@@ -0,0 +1,52 @@
+/**
+ * Database mocking utilities for service tests
+ * Provides simplified mocks for src/database/index module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard database mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @param client Database client to mock (default: 'postgres')
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('../../src/database/index', () => mockDatabase());
+ *
+ * // For MySQL-specific tests
+ * vi.mock('../../src/database/index', () => mockDatabase('mysql'));
+ *
+ * // To dynamically change the client during tests, import and mock directly:
+ * import { getDatabaseClient } from '../database/index.js';
+ * vi.mocked(getDatabaseClient).mockReturnValue('mssql');
+ * ```
+ */
+export function mockDatabase(client = 'postgres') {
+    return {
+        default: vi.fn(),
+        getDatabaseClient: vi.fn().mockReturnValue(client),
+        getSchemaInspector: vi.fn(),
+    };
+}
+/**
+ * Creates a mock for the transaction utility
+ * By default, the mock simply executes the callback with the provided knex instance
+ * (no actual transaction wrapper, which is fine for most service tests)
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * vi.mock('../utils/transaction.js', async () => {
+ *   const { mockTransaction } = await import('../__mocks__/database.js');
+ *   return mockTransaction();
+ * });
+ * ```
+ */
+export function mockTransaction() {
+    return {
+        transaction: vi.fn((knex, callback) => callback(knex)),
+    };
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Emitter mocking utilities for service tests
+ * Provides simplified mocks for src/emitter module used in service testing
+ */
+/**
+ * Creates a standard emitter mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('../emitter.js', () => mockEmitter());
+ *
+ * // To dynamically change emitter behavior during tests, import and mock directly:
+ * import emitter from '../emitter.js';
+ * vi.mocked(emitter.emitAction).mockResolvedValue(undefined);
+ * vi.mocked(emitter.emitFilter).mockResolvedValue(customPayload);
+ * ```
+ */
+export declare function mockEmitter(): {
+    default: {
+        emitAction: import("vitest").Mock<(...args: any[]) => any>;
+        emitFilter: import("vitest").Mock<(_: any, payload: any) => Promise<any>>;
+        emitInit: import("vitest").Mock<(...args: any[]) => any>;
+        onFilter: import("vitest").Mock<(...args: any[]) => any>;
+        onAction: import("vitest").Mock<(...args: any[]) => any>;
+        onInit: import("vitest").Mock<(...args: any[]) => any>;
+        offFilter: import("vitest").Mock<(...args: any[]) => any>;
+        offAction: import("vitest").Mock<(...args: any[]) => any>;
+        offInit: import("vitest").Mock<(...args: any[]) => any>;
+        offAll: import("vitest").Mock<(...args: any[]) => any>;
+    };
+};

package/dist/test-utils/emitter.js

@@ -0,0 +1,38 @@
+/**
+ * Emitter mocking utilities for service tests
+ * Provides simplified mocks for src/emitter module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard emitter mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('../emitter.js', () => mockEmitter());
+ *
+ * // To dynamically change emitter behavior during tests, import and mock directly:
+ * import emitter from '../emitter.js';
+ * vi.mocked(emitter.emitAction).mockResolvedValue(undefined);
+ * vi.mocked(emitter.emitFilter).mockResolvedValue(customPayload);
+ * ```
+ */
+export function mockEmitter() {
+    return {
+        default: {
+            emitAction: vi.fn(),
+            emitFilter: vi.fn((_, payload) => Promise.resolve(payload)),
+            emitInit: vi.fn(),
+            onFilter: vi.fn(),
+            onAction: vi.fn(),
+            onInit: vi.fn(),
+            offFilter: vi.fn(),
+            offAction: vi.fn(),
+            offInit: vi.fn(),
+            offAll: vi.fn(),
+        },
+    };
+}

package/dist/test-utils/fields-service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * FieldsService mocking utilities for service tests
+ * Provides simplified mocks for src/services/fields module used in service testing
+ */
+/**
+ * Creates a standard FieldsService 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('./fields.js', async () => {
+ *   const { mockFieldsService } = await import('../__mocks__/fields-service.js');
+ *   return mockFieldsService();
+ * });
+ *
+ * // To dynamically change FieldsService behavior during tests:
+ * import { FieldsService } from './fields.js';
+ * vi.spyOn(FieldsService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export declare function mockFieldsService(): {
+    FieldsService: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/test-utils/fields-service.js

@@ -0,0 +1,36 @@
+/**
+ * FieldsService mocking utilities for service tests
+ * Provides simplified mocks for src/services/fields module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard FieldsService 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('./fields.js', async () => {
+ *   const { mockFieldsService } = await import('../__mocks__/fields-service.js');
+ *   return mockFieldsService();
+ * });
+ *
+ * // To dynamically change FieldsService behavior during tests:
+ * import { FieldsService } from './fields.js';
+ * vi.spyOn(FieldsService.prototype, 'addColumnToTable').mockImplementation((table, collection, field) => {
+ *   // custom implementation
+ * });
+ * ```
+ */
+export function mockFieldsService() {
+    const FieldsService = vi.fn();
+    // Mock common methods used by other services (like CollectionsService)
+    FieldsService.prototype.addColumnToTable = vi.fn().mockImplementation(() => { });
+    FieldsService.prototype.addColumnIndex = vi.fn().mockResolvedValue(undefined);
+    FieldsService.prototype.deleteField = vi.fn().mockResolvedValue(undefined);
+    FieldsService.prototype.createField = vi.fn().mockResolvedValue(undefined);
+    FieldsService.prototype.updateField = vi.fn().mockResolvedValue('field');
+    return { FieldsService };
+}

package/dist/test-utils/items-service.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ItemsService mocking utilities for service tests
+ * Provides simplified mocks for src/services/items module used in service testing
+ */
+/**
+ * Creates a standard ItemsService mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./items.js', () => mockItemsService());
+ *
+ * // To dynamically change ItemsService behavior during tests, import and mock directly:
+ * import { ItemsService } from './items.js';
+ * vi.spyOn(ItemsService.prototype, 'createOne').mockResolvedValue('new-id');
+ * ```
+ */
+export declare function mockItemsService(): {
+    ItemsService: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/test-utils/items-service.js

@@ -0,0 +1,37 @@
+/**
+ * ItemsService mocking utilities for service tests
+ * Provides simplified mocks for src/services/items module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard ItemsService mock for service tests
+ * This matches the pattern used across all service test files
+ *
+ * @returns Mock module object for vi.mock()
+ *
+ * @example
+ * ```typescript
+ * // Standard usage
+ * vi.mock('./items.js', () => mockItemsService());
+ *
+ * // To dynamically change ItemsService behavior during tests, import and mock directly:
+ * import { ItemsService } from './items.js';
+ * vi.spyOn(ItemsService.prototype, 'createOne').mockResolvedValue('new-id');
+ * ```
+ */
+export function mockItemsService() {
+    const ItemsService = vi.fn();
+    // Provide sensible default return values for common operations
+    ItemsService.prototype.createOne = vi.fn().mockResolvedValue(1);
+    ItemsService.prototype.createMany = vi.fn().mockResolvedValue([1]);
+    ItemsService.prototype.readByQuery = vi.fn().mockResolvedValue([]);
+    ItemsService.prototype.readOne = vi.fn().mockResolvedValue({});
+    ItemsService.prototype.readMany = vi.fn().mockResolvedValue([]);
+    ItemsService.prototype.updateOne = vi.fn().mockResolvedValue(1);
+    ItemsService.prototype.updateMany = vi.fn().mockResolvedValue([1]);
+    ItemsService.prototype.updateByQuery = vi.fn().mockResolvedValue([1]);
+    ItemsService.prototype.deleteOne = vi.fn().mockResolvedValue(1);
+    ItemsService.prototype.deleteMany = vi.fn().mockResolvedValue([1]);
+    ItemsService.prototype.deleteByQuery = vi.fn().mockResolvedValue([1]);
+    return { ItemsService };
+}

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

@@ -0,0 +1,164 @@
+/**
+ * Knex mocking utilities for service tests
+ * Provides mock knex instances, table builders, and tracker utilities
+ */
+import knex from 'knex';
+import { type Tracker } from 'knex-mock-client';
+/**
+ * Creates a mocked knex instance with tracker and schema builder support
+ *
+ * @returns Object containing the mocked db instance, tracker, and mockSchema
+ *
+ * @example
+ * ```typescript
+ * const { db, tracker, mockSchema } = createMockKnex();
+ *
+ * // Use tracker to mock query responses
+ * tracker.on.select('users').response([{ id: 1, name: 'John' }]);
+ *
+ * // Verify schema operations
+ * expect(mockSchema.createTable).toHaveBeenCalled();
+ * ```
+ */
+export declare function createMockKnex(): {
+    db: import("vitest").MockedFunction<knex.Knex<any, unknown[]>>;
+    tracker: Tracker;
+    mockSchemaBuilder: {
+        createTable: import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;
+        dropTable: import("vitest").Mock<(...args: any[]) => any>;
+        hasTable: import("vitest").Mock<(...args: any[]) => any>;
+        table: import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;
+        alterTable: import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;
+        dropTableIfExists: import("vitest").Mock<(...args: any[]) => any>;
+        renameTable: import("vitest").Mock<(...args: any[]) => any>;
+        raw: import("vitest").Mock<(...args: any[]) => any>;
+    };
+};
+/**
+ * Creates a mock table builder for schema operations
+ * Used for testing column creation and alteration
+ *
+ * @returns Mock table builder with chainable methods
+ *
+ * @example
+ * ```typescript
+ * const table = createMockTableBuilder();
+ * table.string('name', 255).notNullable().index();
+ * ```
+ */
+export declare function createMockTableBuilder(): {
+    string: import("vitest").Mock<(...args: any[]) => any>;
+    text: import("vitest").Mock<(...args: any[]) => any>;
+    integer: import("vitest").Mock<(...args: any[]) => any>;
+    bigInteger: import("vitest").Mock<(...args: any[]) => any>;
+    float: import("vitest").Mock<(...args: any[]) => any>;
+    decimal: import("vitest").Mock<(...args: any[]) => any>;
+    boolean: import("vitest").Mock<(...args: any[]) => any>;
+    date: import("vitest").Mock<(...args: any[]) => any>;
+    dateTime: import("vitest").Mock<(...args: any[]) => any>;
+    timestamp: import("vitest").Mock<(...args: any[]) => any>;
+    json: import("vitest").Mock<(...args: any[]) => any>;
+    jsonb: import("vitest").Mock<(...args: any[]) => any>;
+    uuid: import("vitest").Mock<(...args: any[]) => any>;
+    increments: import("vitest").Mock<(...args: any[]) => any>;
+    bigIncrements: import("vitest").Mock<(...args: any[]) => any>;
+    defaultTo: import("vitest").Mock<(...args: any[]) => any>;
+    notNullable: import("vitest").Mock<(...args: any[]) => any>;
+    nullable: import("vitest").Mock<(...args: any[]) => any>;
+    primary: import("vitest").Mock<(...args: any[]) => any>;
+    unique: import("vitest").Mock<(...args: any[]) => any>;
+    index: import("vitest").Mock<(...args: any[]) => any>;
+    alter: import("vitest").Mock<(...args: any[]) => any>;
+    dropColumn: import("vitest").Mock<(...args: any[]) => any>;
+    dropUnique: import("vitest").Mock<(...args: any[]) => any>;
+    dropIndex: import("vitest").Mock<(...args: any[]) => any>;
+};
+/**
+ * Sets up common database operation mock handlers for all system collections
+ * Automatically mocks CRUD operations (select, insert, update, delete) for all Directus system collections
+ *
+ * @param tracker The knex-mock-client tracker instance
+ *
+ * @example
+ * ```typescript
+ * const { db, tracker, mockSchema } = createMockKnex();
+ * setupSystemCollectionMocks(tracker);
+ * // Now all CRUD operations on system collections are mocked
+ * ```
+ */
+export declare function setupSystemCollectionMocks(tracker: Tracker): void;
+/**
+ * Resets all mock states
+ * Should be called in afterEach hooks to clean up between tests
+ *
+ * @param tracker The knex-mock-client tracker instance
+ * @param mockSchema The mock schema object from createMockKnex
+ *
+ * @example
+ * ```typescript
+ * const { db, tracker, mockSchema } = createMockKnex();
+ *
+ * afterEach(() => {
+ *   resetMocks(tracker, mockSchema);
+ * });
+ * ```
+ */
+export declare function resetKnexMocks(tracker: Tracker, mockSchema: ReturnType<typeof createMockKnex>['mockSchemaBuilder']): void;
+/**
+ * Creates a mock createTable function for testing table creation
+ * Returns a vi.fn() that calls the callback with a mock table builder
+ *
+ * @returns Mock function for db.schema.createTable
+ *
+ * @example
+ * ```typescript
+ * const { db } = createMockKnex();
+ * const createTableSpy = mockCreateTable();
+ * db.schema.createTable = createTableSpy as any;
+ *
+ * // Now when createTable is called, it will invoke the callback with a mock table builder
+ * await db.schema.createTable('users', (table) => {
+ *   table.increments('id');
+ *   table.string('name');
+ * });
+ * ```
+ */
+export declare function mockCreateTable(): import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;
+/**
+ * Creates a mock alterTable function for testing schema alterations
+ * Returns a vi.fn() that calls the callback with a mock table builder
+ *
+ * @returns Mock function for db.schema.alterTable
+ *
+ * @example
+ * ```typescript
+ * const { db } = createMockKnex();
+ * const alterTableSpy = mockAlterTable();
+ * db.schema.alterTable = alterTableSpy as any;
+ *
+ * // Now when alterTable is called, it will invoke the callback with a mock table builder
+ * await db.schema.alterTable('users', (table) => {
+ *   table.string('name');
+ * });
+ * ```
+ */
+export declare function mockAlterTable(): import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;
+/**
+ * Creates a mock schema.table function for testing schema operations
+ * Returns a vi.fn() that calls the callback with a mock table builder
+ *
+ * @returns Mock function for db.schema.table
+ *
+ * @example
+ * ```typescript
+ * const { db } = createMockKnex();
+ * const schemaTableSpy = mockSchemaTable();
+ * db.schema.table = schemaTableSpy as any;
+ *
+ * // Now when schema.table is called, it will invoke the callback with a mock table builder
+ * await db.schema.table('users', (table) => {
+ *   table.dropColumn('name');
+ * });
+ * ```
+ */
+export declare function mockSchemaTable(): import("vitest").Mock<(_tableName: any, callback: any) => Promise<void>>;