@directus/api 30.0.0 → 32.0.0

package/dist/database/migrations/20250813A-add-mcp.js

@@ -0,0 +1,18 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.boolean('mcp_enabled').defaultTo(false).notNullable();
+        table.boolean('mcp_allow_deletes').defaultTo(false).notNullable();
+        table.string('mcp_prompts_collection').defaultTo(null).nullable();
+        table.boolean('mcp_system_prompt_enabled').defaultTo(true).notNullable();
+        table.text('mcp_system_prompt').defaultTo(null).nullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('mcp_enabled');
+        table.dropColumn('mcp_allow_deletes');
+        table.dropColumn('mcp_prompts_collection');
+        table.dropColumn('mcp_system_prompt_enabled');
+        table.dropColumn('mcp_system_prompt');
+    });
+}

package/dist/database/migrations/20251012A-add-field-searchable.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20251012A-add-field-searchable.js

@@ -0,0 +1,10 @@
+export async function up(knex) {
+    await knex.schema.alterTable('directus_fields', (table) => {
+        table.boolean('searchable').defaultTo(true).notNullable();
+    });
+}
+export async function down(knex) {
+    await knex.schema.alterTable('directus_fields', (table) => {
+        table.dropColumn('searchable');
+    });
+}

package/dist/database/migrations/20251014A-add-project-owner.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20251014A-add-project-owner.js

@@ -0,0 +1,37 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import { SettingsService } from '../../services/settings.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { email } from 'zod';
+export async function up(knex) {
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.string('project_owner');
+        table.string('project_usage');
+        table.string('org_name');
+        table.boolean('product_updates');
+        table.string('project_status');
+        table.dropColumn('accepted_terms');
+    });
+    const env = useEnv();
+    const settingsService = new SettingsService({ schema: await getSchema() });
+    if (email().safeParse(env['PROJECT_OWNER']).success) {
+        await settingsService.setOwner({
+            project_owner: env['PROJECT_OWNER'],
+            org_name: null,
+            project_usage: null,
+            product_updates: false,
+        });
+    }
+}
+export async function down(knex) {
+    const env = useEnv();
+    const acceptedTerms = toBoolean(env['ACCEPT_TERMS']);
+    await knex.schema.alterTable('directus_settings', (table) => {
+        table.dropColumn('project_owner');
+        table.dropColumn('project_usage');
+        table.dropColumn('org_name');
+        table.dropColumn('product_updates');
+        table.dropColumn('project_status');
+        table.boolean('accepted_terms').defaultTo(acceptedTerms);
+    });
+}

package/dist/database/migrations/20251028A-add-retention-indexes.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function up(knex: Knex): Promise<void>;
+export declare function down(knex: Knex): Promise<void>;

package/dist/database/migrations/20251028A-add-retention-indexes.js

@@ -0,0 +1,42 @@
+import { FieldsService } from '../../services/fields.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { transaction } from '../../utils/transaction.js';
+import { getHelpers } from '../helpers/index.js';
+import { getDatabaseClient } from '../index.js';
+const RETENTION_INDEXES = [
+    { collection: 'directus_activity', field: 'timestamp', ignore: [] },
+    // MySQL is ignored because it already has an index on revisions.parent
+    { collection: 'directus_revisions', field: 'parent', ignore: ['mysql'] },
+];
+export async function up(knex) {
+    const client = getDatabaseClient(knex);
+    const helpers = getHelpers(knex);
+    const schema = await getSchema();
+    const service = new FieldsService({ knex, schema });
+    for (const { collection, field, ignore } of RETENTION_INDEXES) {
+        if (ignore.includes(client))
+            continue;
+        const existingColumn = await service.columnInfo(collection, field);
+        if (!existingColumn.is_indexed) {
+            await helpers.schema.createIndex(collection, field, { attemptConcurrentIndex: true });
+        }
+    }
+}
+export async function down(knex) {
+    const client = getDatabaseClient(knex);
+    const helpers = getHelpers(knex);
+    const schema = await getSchema();
+    const service = new FieldsService({ knex, schema });
+    for (const { collection, field, ignore } of RETENTION_INDEXES) {
+        if (ignore.includes(client))
+            continue;
+        const existingColumn = await service.columnInfo(collection, field);
+        if (existingColumn.is_indexed) {
+            await transaction(knex, async (trx) => {
+                await trx.schema.alterTable(collection, async (table) => {
+                    table.dropIndex([field], helpers.schema.generateIndexName('index', collection, field));
+                });
+            });
+        }
+    }
+}

package/dist/database/run-ast/README.md

@@ -0,0 +1,46 @@
+# Internal RunAst Documentation
+
+As the `runAst()` function is a crucial and complex part of Directus, this document intends to get you started by
+providing a high level overview.
+
+## AST
+
+When a request is made through REST, GQL or WebSockets, we internally turn this request into an AST before this AST
+get's translated into one or more SQL requests which are then send to the database.
+
+On the root level of an AST is the root node which then references a list of child nodes. Each child node can be either
+a primitive field (FieldNode), a relational field (M2ONode, O2MNode, A2MNode) or a function field (FunctionFieldNode).
+Relational fields can also have additional children and nested queries.
+
+### FieldNode
+
+Describes a primitive field and is also a leaf node of the AST.
+
+### Relational Fields
+
+The M2ONode, O2MNode and A2MNode all will recursively call the `runAst()` function and the resulting data will then be
+injected into the data of the level above.
+
+### FunctionFieldNode
+
+The only case where a function field node get's inserted into the ast, is for the count(o2m_relation) case, all other
+functions are kept as FieldNode's with the name containing the function.
+
+## RunAst()
+
+The `runAst()` does translates the AST into an executable SQL request, requests the appropiate data from the database
+and then returns a single or a list of items as the result.
+
+### GetDBQuery()
+
+The RootNode and relational fields have each their own query parameters. These parameters need to be applied to the SQL
+query. This is done by the `getDBQuery()` function which internally uses `applyQuery()`.
+
+<!-- TODO: Describe in larger detail what the GetDBQuery exactly does, i.e. why and when does it need an inner query, why does it sometimes call applyQuery() multiple times in different places -->
+
+#### ApplyQuery()
+
+`applyQuery()` takes the query and modifies the SQL request so that filters, sorts and all the other variants of query
+parameters are applied.A special behaviour is filtering, sorting or other parameters on nested fields. To make this
+possible, the `addJoin()` joins the required tables and then registers itself into the aliasMap so that the next time
+the same collection should be joined, instead it will just reuse the already existing join.

package/dist/database/run-ast/lib/apply-query/add-join.js

@@ -2,7 +2,7 @@ import { InvalidQueryError } from '@directus/errors';
 import { clone } from 'lodash-es';
 import { getRelationInfo } from '../../../../utils/get-relation-info.js';
 import { getHelpers } from '../../../helpers/index.js';
-import { generateAlias } from './index.js';
+import { generateJoinAlias } from '../../utils/generate-alias.js';
 export function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {
     let hasMultiRelational = false;
     let isJoinAdded = false;
@@ -22,7 +22,7 @@ export function addJoin({ path, collection, aliasMap, rootQuery, schema, knex })
             ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias
             : aliasMap[pathParts[0]]?.alias;
         if (!existingAlias) {
-            const alias = generateAlias();
+            const alias = generateJoinAlias(parentCollection, pathParts, relationType, parentFields);
             const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
             const aliasedParentCollection = aliasMap[parentFields ?? '']?.alias || parentCollection;
             aliasMap[aliasKey] = { alias, collection: '' };

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.d.ts

@@ -1,8 +1,8 @@
 import type { FieldOverview } from '@directus/types';
 export declare function getFilterType(fields: Record<string, FieldOverview>, key: string, collection?: string): {
-    type: "string" | "boolean" | "json" | "text" | "integer" | "float" | "alias" | "uuid" | "binary" | "time" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    type: "string" | "boolean" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
     special?: never;
 } | {
-    type: "string" | "boolean" | "json" | "text" | "integer" | "float" | "alias" | "uuid" | "binary" | "time" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    type: "string" | "boolean" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "json" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
     special: string[];
 };

package/dist/database/run-ast/lib/apply-query/index.d.ts

@@ -1,7 +1,6 @@
 import type { Filter, Permission, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { AliasMap } from '../../../../utils/get-column-path.js';
-export declare const generateAlias: (size?: number) => string;
 type ApplyQueryOptions = {
     aliasMap?: AliasMap;
     isInnerQuery?: boolean;

package/dist/database/run-ast/lib/apply-query/index.js

@@ -1,14 +1,12 @@
-import { customAlphabet } from 'nanoid/non-secure';
 import { getHelpers } from '../../../helpers/index.js';
 import { applyCaseWhen } from '../../utils/apply-case-when.js';
 import { getColumn } from '../../utils/get-column.js';
-import { applyLimit, applyOffset } from './pagination.js';
-import { joinFilterWithCases } from './join-filter-with-cases.js';
-import { applySort } from './sort.js';
+import { applyAggregate } from './aggregate.js';
 import { applyFilter } from './filter/index.js';
+import { joinFilterWithCases } from './join-filter-with-cases.js';
+import { applyLimit, applyOffset } from './pagination.js';
 import { applySearch } from './search.js';
-import { applyAggregate } from './aggregate.js';
-export const generateAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
+import { applySort } from './sort.js';
 /**
  * Apply the Query to a given Knex query builder instance
  */

package/dist/database/run-ast/lib/apply-query/search.js

@@ -9,6 +9,8 @@ export function applySearch(knex, schema, dbQuery, searchQuery, collection, alia
     const { number: numberHelper } = getHelpers(knex);
     const allowedFields = new Set(permissions.filter((p) => p.collection === collection).flatMap((p) => p.fields ?? []));
     let fields = Object.entries(schema.collections[collection].fields);
+    // filter out fields that are not searchable
+    fields = fields.filter(([_name, field]) => field.searchable !== false && field.special.includes('conceal') !== true);
     const { cases, caseMap } = getCases(collection, permissions, []);
     // Add field restrictions if non-admin and "everything" is not allowed
     if (cases.length !== 0 && !allowedFields.has('*')) {

package/dist/database/run-ast/lib/get-db-query.js

@@ -1,16 +1,17 @@
 import { useEnv } from '@directus/env';
 import { cloneDeep } from 'lodash-es';
-import { applySort } from './apply-query/sort.js';
 import { getCollectionFromAlias } from '../../../utils/get-collection-from-alias.js';
-import { getColumn } from '../utils/get-column.js';
 import { getHelpers } from '../../helpers/index.js';
 import { applyCaseWhen } from '../utils/apply-case-when.js';
+import { generateQueryAlias } from '../utils/generate-alias.js';
 import { getColumnPreprocessor } from '../utils/get-column-pre-processor.js';
+import { getColumn } from '../utils/get-column.js';
 import { getNodeAlias } from '../utils/get-field-alias.js';
 import { getInnerQueryColumnPreProcessor } from '../utils/get-inner-query-column-pre-processor.js';
 import { withPreprocessBindings } from '../utils/with-preprocess-bindings.js';
-import applyQuery, { generateAlias } from './apply-query/index.js';
+import applyQuery from './apply-query/index.js';
 import { applyLimit } from './apply-query/pagination.js';
+import { applySort } from './apply-query/sort.js';
 export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissions, permissionsOnly }, { knex, schema }) {
     const aliasMap = Object.create(null);
     const env = useEnv();
@@ -95,11 +96,11 @@ export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissi
         if (needsInnerQuery) {
             let orderByString = '';
             const orderByFields = [];
-            sortRecords.map((sortRecord) => {
+            sortRecords.map((sortRecord, index) => {
                 if (orderByString.length !== 0) {
                     orderByString += ', ';
                 }
-                const sortAlias = `sort_${generateAlias()}`;
+                const sortAlias = generateQueryAlias(table, queryCopy, `sort_${index}_${sortRecord.column}_${sortRecord.order}`);
                 let orderByColumn;
                 if (sortRecord.column.includes('.')) {
                     const [alias, field] = sortRecord.column.split('.');
@@ -146,7 +147,7 @@ export function getDBQuery({ table, fieldNodes, o2mNodes, query, cases, permissi
     }
     if (!needsInnerQuery)
         return dbQuery;
-    const innerCaseWhenAliasPrefix = generateAlias();
+    const innerCaseWhenAliasPrefix = generateQueryAlias(table, queryCopy, 'inner_case_when');
     if (hasCaseWhen) {
         /* If there are cases, we need to employ a trick in order to evaluate the case/when structure in the inner query,
            while passing the result of the evaluation to the outer query. The case/when needs to be evaluated in the inner

package/dist/database/run-ast/utils/generate-alias.d.ts

@@ -0,0 +1,6 @@
+import type { Query } from '@directus/types';
+import type { FnHelperOptions } from '../../helpers/fn/types.js';
+export declare function generateAlias(context?: string): string;
+export declare function generateQueryAlias(table: string, query: Query, path?: string): string;
+export declare function generateRelationalQueryAlias(table: string, column: string, collectionName: string, options?: FnHelperOptions): string;
+export declare function generateJoinAlias(collection: string, path: string[], relationType: string | null, parentFields?: string): string;

package/dist/database/run-ast/utils/generate-alias.js

@@ -0,0 +1,57 @@
+import { getSimpleHash } from '@directus/utils';
+import { customAlphabet } from 'nanoid/non-secure';
+// Fallback to original random alias generator
+const generateRandomAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
+// Context-aware alias generator
+export function generateAlias(context = '') {
+    if (context) {
+        return generateDeterministicAlias(context);
+    }
+    return generateRandomAlias();
+}
+// Create a deterministic alias for general query contexts
+export function generateQueryAlias(table, query, path = '') {
+    const context = JSON.stringify({
+        table,
+        path,
+        sort: query.sort,
+        group: query.group,
+        aggregate: query.aggregate,
+        // Exclude: limit, offset, page, search, filter - these are execution parameters
+        // that don't affect the underlying query structure requiring aliases
+    });
+    return generateDeterministicAlias(context);
+}
+// Create a deterministic context for relational count aliases
+export function generateRelationalQueryAlias(table, column, collectionName, options) {
+    const context = JSON.stringify({
+        table,
+        column,
+        collectionName,
+        filter: options?.relationalCountOptions?.query?.filter,
+    });
+    return generateDeterministicAlias(context);
+}
+// Create a deterministic alias for join contexts
+export function generateJoinAlias(collection, path, relationType, parentFields = '') {
+    const context = JSON.stringify({
+        collection,
+        path: path.join('.'),
+        relationType,
+        parentFields,
+    });
+    return generateDeterministicAlias(context);
+}
+// Generate deterministic alias based on context
+function generateDeterministicAlias(context = '') {
+    const hash = getSimpleHash(context);
+    const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+    let result = '';
+    let num = parseInt(hash, 16);
+    // Generate 5 character alias
+    for (let i = 0; i < 5; i++) {
+        result += alphabet[num % alphabet.length];
+        num = Math.floor(num / alphabet.length);
+    }
+    return result;
+}

package/dist/flows.js

@@ -291,6 +291,7 @@ class FlowManager {
             [ACCOUNTABILITY_KEY]: context?.['accountability'] ?? null,
             [ENV_KEY]: this.envs,
         };
+        context['flow'] ??= flow;
         let nextOperation = flow.operation;
         let lastOperationStatus = 'unknown';
         const steps = [];

package/dist/mcp/define.d.ts

@@ -0,0 +1,2 @@
+import type { ToolConfig } from './types.js';
+export declare function defineTool<Args>(tool: ToolConfig<Args>): ToolConfig<Args>;

package/dist/mcp/define.js

@@ -0,0 +1,3 @@
+export function defineTool(tool) {
+    return tool;
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1 @@
+export * from './server.js';

package/dist/mcp/index.js

@@ -0,0 +1 @@
+export * from './server.js';