@directus/api 30.0.0 → 32.0.0

package/dist/test-utils/knex.js

@@ -0,0 +1,268 @@
+/**
+ * Knex mocking utilities for service tests
+ * Provides mock knex instances, table builders, and tracker utilities
+ */
+import { systemCollectionNames } from '@directus/system-data';
+import knex from 'knex';
+import { MockClient, createTracker } from 'knex-mock-client';
+import { vi } from 'vitest';
+/**
+ * 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 function createMockKnex() {
+    const db = vi.mocked(knex.default({ client: MockClient }));
+    const tracker = createTracker(db);
+    // Mock schema builder methods with functional callbacks
+    const mockSchemaBuilder = {
+        createTable: vi.fn((_tableName, callback) => {
+            callback(createMockTableBuilder());
+            return Promise.resolve();
+        }),
+        dropTable: vi.fn().mockResolvedValue(undefined),
+        hasTable: vi.fn().mockResolvedValue(false),
+        table: vi.fn((_tableName, callback) => {
+            callback(createMockTableBuilder());
+            return Promise.resolve();
+        }),
+        alterTable: vi.fn((_tableName, callback) => {
+            callback(createMockTableBuilder());
+            return Promise.resolve();
+        }),
+        dropTableIfExists: vi.fn().mockResolvedValue(undefined),
+        renameTable: vi.fn().mockResolvedValue(undefined),
+        raw: vi.fn().mockResolvedValue(undefined),
+    };
+    Object.defineProperty(db, 'schema', {
+        get: () => mockSchemaBuilder,
+        configurable: true,
+    });
+    // Note: We do NOT override the query builder methods (select, where, from, etc.)
+    // because knex-mock-client already provides them and connects them to the tracker.
+    // Overriding them would break the tracker connection and cause queries to not return
+    // the mocked responses.
+    return { db, tracker, mockSchemaBuilder };
+}
+/**
+ * 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 function createMockTableBuilder() {
+    return {
+        // Column types - actively used
+        string: vi.fn().mockReturnThis(),
+        text: vi.fn().mockReturnThis(),
+        integer: vi.fn().mockReturnThis(),
+        bigInteger: vi.fn().mockReturnThis(),
+        float: vi.fn().mockReturnThis(),
+        decimal: vi.fn().mockReturnThis(),
+        boolean: vi.fn().mockReturnThis(),
+        date: vi.fn().mockReturnThis(),
+        dateTime: vi.fn().mockReturnThis(),
+        timestamp: vi.fn().mockReturnThis(),
+        json: vi.fn().mockReturnThis(),
+        jsonb: vi.fn().mockReturnThis(),
+        uuid: vi.fn().mockReturnThis(),
+        // Column types - unused
+        // tinyint: vi.fn().mockReturnThis(),
+        // smallint: vi.fn().mockReturnThis(),
+        // mediumint: vi.fn().mockReturnThis(),
+        // bigint: vi.fn().mockReturnThis(),
+        // double: vi.fn().mockReturnThis(),
+        // datetime: vi.fn().mockReturnThis(),
+        // time: vi.fn().mockReturnThis(),
+        // timestamps: vi.fn().mockReturnThis(),
+        // binary: vi.fn().mockReturnThis(),
+        // enum: vi.fn().mockReturnThis(),
+        // enu: vi.fn().mockReturnThis(),
+        // geometry: vi.fn().mockReturnThis(),
+        // geography: vi.fn().mockReturnThis(),
+        // point: vi.fn().mockReturnThis(),
+        // linestring: vi.fn().mockReturnThis(),
+        // polygon: vi.fn().mockReturnThis(),
+        // multipoint: vi.fn().mockReturnThis(),
+        // multilinestring: vi.fn().mockReturnThis(),
+        // multipolygon: vi.fn().mockReturnThis(),
+        // geometrycollection: vi.fn().mockReturnThis(),
+        // specificType: vi.fn().mockReturnThis(),
+        // Auto-increment columns
+        increments: vi.fn().mockReturnThis(),
+        bigIncrements: vi.fn().mockReturnThis(),
+        // Column modifiers - actively used
+        defaultTo: vi.fn().mockReturnThis(),
+        notNullable: vi.fn().mockReturnThis(),
+        nullable: vi.fn().mockReturnThis(),
+        primary: vi.fn().mockReturnThis(),
+        unique: vi.fn().mockReturnThis(),
+        index: vi.fn().mockReturnThis(),
+        alter: vi.fn().mockReturnThis(),
+        // Column modifiers - unused
+        // unsigned: vi.fn().mockReturnThis(),
+        // comment: vi.fn().mockReturnThis(),
+        // collate: vi.fn().mockReturnThis(),
+        // charset: vi.fn().mockReturnThis(),
+        // first: vi.fn().mockReturnThis(),
+        // after: vi.fn().mockReturnThis(),
+        // references: vi.fn().mockReturnThis(),
+        // inTable: vi.fn().mockReturnThis(),
+        // onDelete: vi.fn().mockReturnThis(),
+        // onUpdate: vi.fn().mockReturnThis(),
+        // foreign: vi.fn().mockReturnThis(),
+        // Schema alterations - actively used
+        dropColumn: vi.fn().mockReturnThis(),
+        dropUnique: vi.fn().mockReturnThis(),
+        dropIndex: vi.fn().mockReturnThis(),
+        // Schema alterations - unused
+        // dropColumns: vi.fn().mockReturnThis(),
+        // renameColumn: vi.fn().mockReturnThis(),
+        // dropPrimary: vi.fn().mockReturnThis(),
+        // dropForeign: vi.fn().mockReturnThis(),
+        // dropTimestamps: vi.fn().mockReturnThis(),
+        // Table options - unused
+        // engine: vi.fn().mockReturnThis(),
+        // inherits: vi.fn().mockReturnThis(),
+        // queryContext: vi.fn().mockReturnThis(),
+    };
+}
+/**
+ * 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 function setupSystemCollectionMocks(tracker) {
+    // Mock all CRUD operations for all system collections
+    for (const collection of systemCollectionNames) {
+        tracker.on.select(collection).response([]);
+        tracker.on.insert(collection).response([]);
+        tracker.on.update(collection).response([]);
+        tracker.on.delete(collection).response([]);
+    }
+}
+/**
+ * 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 function resetKnexMocks(tracker, mockSchema) {
+    tracker.reset();
+    vi.clearAllMocks();
+    mockSchema.createTable.mockClear();
+    mockSchema.dropTable.mockClear();
+    mockSchema.hasTable.mockClear();
+    mockSchema.table.mockClear();
+    if (mockSchema.alterTable) {
+        mockSchema.alterTable.mockClear();
+    }
+}
+/**
+ * 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 function mockCreateTable() {
+    return vi.fn((_tableName, callback) => {
+        callback(createMockTableBuilder());
+        return Promise.resolve();
+    });
+}
+/**
+ * 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 function mockAlterTable() {
+    return vi.fn((_tableName, callback) => {
+        callback(createMockTableBuilder());
+        return Promise.resolve();
+    });
+}
+/**
+ * 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 function mockSchemaTable() {
+    return vi.fn((_tableName, callback) => {
+        callback(createMockTableBuilder());
+        return Promise.resolve();
+    });
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Schema mocking utilities for service tests
+ * Provides simplified mocks for @directus/schema module used in service testing
+ */
+/**
+ * Creates a standard schema inspector 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('@directus/schema', () => mockSchema());
+ *
+ * // To dynamically change inspector behavior during tests, import and mock directly:
+ * import { createInspector } from '@directus/schema';
+ * vi.mocked(createInspector).mockReturnValue({
+ *   tableInfo: vi.fn().mockResolvedValue([{ name: 'custom_table' }]),
+ *   // ... other custom behaviors
+ * });
+ * ```
+ */
+export declare function mockSchema(): {
+    createInspector: import("vitest").Mock<(...args: any[]) => any>;
+};

package/dist/test-utils/schema.js

@@ -0,0 +1,35 @@
+/**
+ * Schema mocking utilities for service tests
+ * Provides simplified mocks for @directus/schema module used in service testing
+ */
+import { vi } from 'vitest';
+/**
+ * Creates a standard schema inspector 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('@directus/schema', () => mockSchema());
+ *
+ * // To dynamically change inspector behavior during tests, import and mock directly:
+ * import { createInspector } from '@directus/schema';
+ * vi.mocked(createInspector).mockReturnValue({
+ *   tableInfo: vi.fn().mockResolvedValue([{ name: 'custom_table' }]),
+ *   // ... other custom behaviors
+ * });
+ * ```
+ */
+export function mockSchema() {
+    return {
+        createInspector: vi.fn().mockReturnValue({
+            tableInfo: vi.fn().mockResolvedValue([]),
+            columnInfo: vi.fn().mockResolvedValue([]),
+            primary: vi.fn().mockResolvedValue('id'),
+            foreignKeys: vi.fn().mockResolvedValue([]),
+            withSchema: vi.fn().mockReturnThis(),
+        }),
+    };
+}

package/dist/types/auth.d.ts

@@ -1,8 +1,6 @@
-import type { SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 export interface AuthDriverOptions {
     knex: Knex;
-    schema: SchemaOverview;
 }
 export interface User {
     id: string;
@@ -27,10 +25,11 @@ export interface Session {
 export type DirectusTokenPayload = {
     id?: string;
     role: string | null;
-    session?: string;
     app_access: boolean | number;
     admin_access: boolean | number;
     share?: string;
+    session?: string;
+    enforce_tfa?: boolean;
 };
 export type ShareData = {
     share_id: string;

package/dist/utils/apply-diff.js

@@ -205,6 +205,21 @@ export async function applyDiff(currentSnapshot, snapshotDiff, options) {
                     !relation.diff.some((diff) => diff.kind === DiffKind.NEW)) === false);
             }
         }
+        for (const { collection, field, diff } of snapshotDiff.systemFields) {
+            if (diff?.[0]?.kind === DiffKind.EDIT) {
+                try {
+                    const newValues = diff.reduce((acc, currentDiff) => {
+                        deepDiff.applyChange(acc, undefined, currentDiff);
+                        return acc;
+                    }, { collection, field });
+                    await fieldsService.updateField(collection, newValues, mutationOptions);
+                }
+                catch (err) {
+                    logger.error(`Failed to update field "${collection}.${field}"`);
+                    throw err;
+                }
+            }
+        }
         const relationsService = new RelationsService({
             knex: trx,
             schema: await getSchema({ database: trx, bypassCache: true }),

package/dist/utils/create-admin.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Policy, Role, User } from '@directus/types';
+export declare const defaultAdminRole: Partial<Role>;
+export declare const defaultAdminUser: Partial<User>;
+export declare const defaultAdminPolicy: Partial<Policy>;
+export declare function createAdmin(schema: SchemaOverview, admin?: {
+    email?: string;
+    password?: string;
+    first_name?: string;
+    last_name?: string;
+}): Promise<void>;

package/dist/utils/create-admin.js

@@ -0,0 +1,50 @@
+import { useEnv } from '@directus/env';
+import { useLogger } from '../logger/index.js';
+import { AccessService } from '../services/access.js';
+import { UsersService } from '../services/index.js';
+import { PoliciesService } from '../services/policies.js';
+import { RolesService } from '../services/roles.js';
+export const defaultAdminRole = {
+    name: 'Administrator',
+    icon: 'verified',
+    description: '$t:admin_description',
+};
+export const defaultAdminUser = {
+    status: 'active',
+    first_name: 'Admin',
+    last_name: 'User',
+};
+export const defaultAdminPolicy = {
+    name: 'Administrator',
+    icon: 'verified',
+    admin_access: true,
+    app_access: true,
+    description: '$t:admin_description',
+};
+export async function createAdmin(schema, admin) {
+    const logger = useLogger();
+    const env = useEnv();
+    logger.info('Setting up first admin role...');
+    const accessService = new AccessService({ schema });
+    const policiesService = new PoliciesService({ schema });
+    const rolesService = new RolesService({ schema });
+    const role = await rolesService.createOne(defaultAdminRole);
+    const policy = await policiesService.createOne(defaultAdminPolicy);
+    await accessService.createOne({ policy, role });
+    const usersService = new UsersService({ schema });
+    const adminEmail = admin?.email ?? env['ADMIN_EMAIL'];
+    const adminPassword = admin?.password ?? env['ADMIN_PASSWORD'];
+    if (!adminEmail || !adminPassword)
+        return;
+    const token = env['ADMIN_TOKEN'] ?? null;
+    logger.info('Adding first admin user...');
+    await usersService.createOne({
+        ...defaultAdminUser,
+        first_name: admin?.first_name ?? defaultAdminUser.first_name,
+        last_name: admin?.last_name ?? defaultAdminUser.last_name,
+        email: adminEmail,
+        password: adminPassword,
+        token,
+        role,
+    });
+}

package/dist/utils/get-schema.js

@@ -1,7 +1,7 @@
 import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
 import { systemCollectionRows } from '@directus/system-data';
-import { parseJSON, toArray } from '@directus/utils';
+import { parseJSON, toArray, toBoolean } from '@directus/utils';
 import { mapValues } from 'lodash-es';
 import { useBus } from '../bus/index.js';
 import { getMemorySchemaCache, setMemorySchemaCache } from '../cache.js';
@@ -106,7 +106,7 @@ async function getDatabaseSchema(database, schemaInspector) {
         result.collections[collection] = {
             collection,
             primary: info.primary,
-            singleton: collectionMeta?.singleton === true || collectionMeta?.singleton === 'true' || collectionMeta?.singleton === 1,
+            singleton: toBoolean(collectionMeta?.singleton),
             note: collectionMeta?.note || null,
             sortField: collectionMeta?.sort_field || null,
             accountability: collectionMeta ? collectionMeta.accountability : 'all',
@@ -124,13 +124,14 @@ async function getDatabaseSchema(database, schemaInspector) {
                     note: null,
                     validation: null,
                     alias: false,
+                    searchable: true,
                 };
             }),
         };
     }
     const fields = [
         ...(await database
-            .select('id', 'collection', 'field', 'special', 'note', 'validation')
+            .select('id', 'collection', 'field', 'special', 'note', 'validation', 'searchable')
             .from('directus_fields')),
         ...systemFieldRows,
     ].filter((field) => (field.special ? toArray(field.special) : []).includes('no-data') === false);
@@ -159,6 +160,7 @@ async function getDatabaseSchema(database, schemaInspector) {
             note: field.note,
             alias: existing?.alias ?? true,
             validation: validation ?? null,
+            searchable: toBoolean(field.searchable) ?? true,
         };
     }
     const relationsService = new RelationsService({ knex: database, schema: result });

package/dist/utils/get-snapshot-diff.js

@@ -1,14 +1,15 @@
 import deepDiff from 'deep-diff';
 import { DiffKind } from '@directus/types';
-import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
+import { sanitizeCollection, sanitizeField, sanitizeRelation, sanitizeSystemField } from './sanitize-schema.js';
 export function getSnapshotDiff(current, after) {
     const diffedSnapshot = {
         collections: [
             ...current.collections.map((currentCollection) => {
                 const afterCollection = after.collections.find((afterCollection) => afterCollection.collection === currentCollection.collection);
+                const afterCollectionSanitized = afterCollection ? sanitizeCollection(afterCollection) : undefined;
                 return {
                     collection: currentCollection.collection,
-                    diff: deepDiff.diff(sanitizeCollection(currentCollection), sanitizeCollection(afterCollection)),
+                    diff: deepDiff.diff(sanitizeCollection(currentCollection), afterCollectionSanitized),
                 };
             }),
             ...after.collections
@@ -32,13 +33,14 @@ export function getSnapshotDiff(current, after) {
                     return {
                         collection: currentField.collection,
                         field: currentField.field,
-                        diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), sanitizeField(undefined, isAutoIncrementPrimaryKey)),
+                        diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), undefined),
                     };
                 }
+                const afterFieldSanitized = afterField ? sanitizeField(afterField, isAutoIncrementPrimaryKey) : undefined;
                 return {
                     collection: currentField.collection,
                     field: currentField.field,
-                    diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), sanitizeField(afterField, isAutoIncrementPrimaryKey)),
+                    diff: deepDiff.diff(sanitizeField(currentField, isAutoIncrementPrimaryKey), afterFieldSanitized),
                 };
             }),
             ...after.fields
@@ -58,14 +60,49 @@ export function getSnapshotDiff(current, after) {
                 diff: deepDiff.diff(undefined, sanitizeField(afterField)),
             })),
         ].filter((obj) => Array.isArray(obj.diff)),
+        systemFields: [
+            ...(current.systemFields ?? []).map((currentSystemField) => {
+                const afterSystemField = (after.systemFields ?? []).find((afterSystemField) => afterSystemField.collection === currentSystemField.collection &&
+                    afterSystemField.field === currentSystemField.field);
+                const afterSystemFieldSanitized = afterSystemField
+                    ? sanitizeSystemField(afterSystemField)
+                    : invertIndexed(currentSystemField);
+                return {
+                    collection: currentSystemField.collection,
+                    field: currentSystemField.field,
+                    diff: deepDiff.diff(sanitizeSystemField(currentSystemField), afterSystemFieldSanitized),
+                };
+            }),
+            ...(after.systemFields ?? [])
+                .filter((afterSystemField) => {
+                if (!afterSystemField.schema.is_indexed)
+                    return false;
+                const currentSystemField = (current.systemFields ?? []).find((currentSystemField) => currentSystemField.collection === afterSystemField.collection &&
+                    afterSystemField.field === currentSystemField.field);
+                return Boolean(currentSystemField) === false;
+            })
+                .map((afterSystemField) => {
+                const currentSystemField = (current.systemFields ?? []).find((currentSystemField) => currentSystemField.collection === afterSystemField.collection &&
+                    currentSystemField.field === afterSystemField.field);
+                const currentSystemFieldSanitized = currentSystemField
+                    ? sanitizeSystemField(currentSystemField)
+                    : invertIndexed(afterSystemField);
+                return {
+                    collection: afterSystemField.collection,
+                    field: afterSystemField.field,
+                    diff: deepDiff.diff(currentSystemFieldSanitized, sanitizeSystemField(afterSystemField)),
+                };
+            }),
+        ].filter((obj) => Array.isArray(obj.diff)),
         relations: [
             ...current.relations.map((currentRelation) => {
                 const afterRelation = after.relations.find((afterRelation) => afterRelation.collection === currentRelation.collection && afterRelation.field === currentRelation.field);
+                const afterRelationSanitized = afterRelation ? sanitizeRelation(afterRelation) : undefined;
                 return {
                     collection: currentRelation.collection,
                     field: currentRelation.field,
                     related_collection: currentRelation.related_collection,
-                    diff: deepDiff.diff(sanitizeRelation(currentRelation), sanitizeRelation(afterRelation)),
+                    diff: deepDiff.diff(sanitizeRelation(currentRelation), afterRelationSanitized),
                 };
             }),
             ...after.relations
@@ -91,3 +128,10 @@ export function getSnapshotDiff(current, after) {
     diffedSnapshot.relations = diffedSnapshot.relations.filter((relation) => deletedCollections.includes(relation.collection) === false);
     return diffedSnapshot;
 }
+function invertIndexed(field) {
+    const newSchema = { ...field.schema };
+    if ('is_indexed' in field.schema) {
+        newSchema.is_indexed = !field.schema.is_indexed;
+    }
+    return { ...field, schema: newSchema };
+}

package/dist/utils/get-snapshot.js

@@ -5,7 +5,7 @@ import { CollectionsService } from '../services/collections.js';
 import { FieldsService } from '../services/fields.js';
 import { RelationsService } from '../services/relations.js';
 import { getSchema } from './get-schema.js';
-import { sanitizeCollection, sanitizeField, sanitizeRelation } from './sanitize-schema.js';
+import { sanitizeCollection, sanitizeField, sanitizeRelation, sanitizeSystemField } from './sanitize-schema.js';
 export async function getSnapshot(options) {
     const database = options?.database ?? getDatabase();
     const vendor = getDatabaseClient(database);
@@ -21,16 +21,19 @@ export async function getSnapshot(options) {
     const collectionsFiltered = collectionsRaw.filter((item) => excludeSystem(item) && excludeUntracked(item));
     const fieldsFiltered = fieldsRaw.filter((item) => excludeSystem(item) && excludeUntracked(item));
     const relationsFiltered = relationsRaw.filter((item) => excludeSystem(item) && excludeUntracked(item));
-    const collectionsSorted = sortBy(mapValues(collectionsFiltered, sortDeep), ['collection']);
-    const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ['collection', 'meta.id']).map(omitID);
-    const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ['collection', 'meta.id']).map(omitID);
+    const systemFieldsFiltered = fieldsRaw.filter((item) => systemFieldWithIndex(item));
+    const collectionsSorted = sortBy(mapValues(collectionsFiltered, sortDeep), ['collection']).map((collection) => sanitizeCollection(collection));
+    const fieldsSorted = sortBy(mapValues(fieldsFiltered, sortDeep), ['collection', 'meta.id']).map((field) => sanitizeField(omitID(field)));
+    const systemFieldsSorted = sortBy(systemFieldsFiltered, ['collection', 'field']).map((field) => sanitizeSystemField(field));
+    const relationsSorted = sortBy(mapValues(relationsFiltered, sortDeep), ['collection', 'meta.id']).map((relation) => sanitizeRelation(omitID(relation)));
     return {
         version: 1,
         directus: version,
         vendor,
-        collections: collectionsSorted.map((collection) => sanitizeCollection(collection)),
-        fields: fieldsSorted.map((field) => sanitizeField(field)),
-        relations: relationsSorted.map((relation) => sanitizeRelation(relation)),
+        collections: collectionsSorted,
+        fields: fieldsSorted,
+        systemFields: systemFieldsSorted,
+        relations: relationsSorted,
     };
 }
 function excludeSystem(item) {
@@ -38,6 +41,9 @@ function excludeSystem(item) {
         return false;
     return true;
 }
+function systemFieldWithIndex(item) {
+    return item.meta?.system === true && item.schema?.is_indexed;
+}
 function excludeUntracked(item) {
     if (item?.meta === null)
         return false;

package/dist/utils/sanitize-schema.d.ts

@@ -1,5 +1,5 @@
 import type { Column } from '@directus/schema';
-import type { Field, Relation } from '@directus/types';
+import type { Field, Relation, SnapshotCollection, SnapshotField, SnapshotRelation, SnapshotSystemField } from '@directus/types';
 import type { Collection } from '../types/index.js';
 /**
  * Pick certain database vendor specific collection properties that should be compared when performing diff
@@ -7,7 +7,7 @@ import type { Collection } from '../types/index.js';
  * @param collection collection to sanitize
  * @returns sanitized collection
  */
-export declare function sanitizeCollection(collection: Collection | undefined): Partial<Collection> | undefined;
+export declare function sanitizeCollection(collection: Collection): SnapshotCollection;
 /**
  * Pick certain database vendor specific field properties that should be compared when performing diff
  *
@@ -15,7 +15,7 @@ export declare function sanitizeCollection(collection: Collection | undefined):
  * @param sanitizeAllSchema Whether or not the whole field schema should be sanitized. Mainly used to prevent modifying autoincrement fields
  * @returns sanitized field
  */
-export declare function sanitizeField(field: Field | undefined, sanitizeAllSchema?: boolean): Partial<Field> | undefined;
+export declare function sanitizeField(field: Field, sanitizeAllSchema?: boolean): SnapshotField;
 export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "foreign_key_table" | "foreign_key_column" | "name" | "data_type" | "default_value" | "max_length" | "numeric_precision" | "numeric_scale" | "is_nullable" | "is_unique" | "is_indexed" | "is_primary_key" | "is_generated" | "generation_expression" | "has_auto_increment">;
 /**
  * Pick certain database vendor specific relation properties that should be compared when performing diff
@@ -23,4 +23,11 @@ export declare function sanitizeColumn(column: Column): Pick<Column, "table" | "
  * @param relation relation to sanitize
  * @returns sanitized relation
  */
-export declare function sanitizeRelation(relation: Relation | undefined): Partial<Relation> | undefined;
+export declare function sanitizeRelation(relation: Relation): SnapshotRelation;
+/**
+ * Pick certain specific system field properties that should be compared when performing diff
+ *
+ * @param field field to sanitize
+ * @returns sanitized system field
+ */
+export declare function sanitizeSystemField(field: Field | SnapshotSystemField): SnapshotSystemField;