@directus/api 31.0.0 → 32.0.0

package/dist/controllers/server.js

@@ -1,10 +1,12 @@
-import { RouteNotFoundError } from '@directus/errors';
+import { ErrorCode, ForbiddenError, isDirectusError, RouteNotFoundError } from '@directus/errors';
 import { format } from 'date-fns';
 import { Router } from 'express';
 import { respond } from '../middleware/respond.js';
+import { SettingsService } from '../services/index.js';
 import { ServerService } from '../services/server.js';
 import { SpecificationService } from '../services/specifications.js';
 import asyncHandler from '../utils/async-handler.js';
+import { createAdmin } from '../utils/create-admin.js';
 const router = Router();
 router.get('/specs/oas', asyncHandler(async (req, res, next) => {
     const service = new SpecificationService({
@@ -54,4 +56,27 @@ router.get('/health', asyncHandler(async (req, res, next) => {
     res.locals['cache'] = false;
     return next();
 }), respond);
+router.post('/setup', asyncHandler(async (req, _res, next) => {
+    const serverService = new ServerService({ schema: req.schema });
+    if (await serverService.isSetupCompleted()) {
+        throw new ForbiddenError();
+    }
+    try {
+        await createAdmin(req.schema, {
+            email: req.body.project_owner,
+            password: req.body.password,
+            first_name: req.body.first_name,
+            last_name: req.body.last_name,
+        });
+        const settingsService = new SettingsService({ schema: req.schema });
+        settingsService.setOwner(req.body);
+    }
+    catch (error) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
+            return next();
+        }
+        throw error;
+    }
+    return next();
+}), respond);
 export default router;

package/dist/controllers/settings.js

@@ -1,6 +1,5 @@
-import { isDirectusError } from '@directus/errors';
+import { ErrorCode, isDirectusError } from '@directus/errors';
 import express from 'express';
-import { ErrorCode } from '@directus/errors';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { SettingsService } from '../services/settings.js';
@@ -16,6 +15,14 @@ router.get('/', asyncHandler(async (req, res, next) => {
     res.locals['payload'] = { data: records || null };
     return next();
 }), respond);
+router.post('/owner', asyncHandler(async (req, _res, next) => {
+    const service = new SettingsService({
+        accountability: req.accountability,
+        schema: req.schema,
+    });
+    await service.setOwner(req.body);
+    return next();
+}), respond);
 router.patch('/', asyncHandler(async (req, res, next) => {
     const service = new SettingsService({
         accountability: req.accountability,

package/dist/controllers/users.js

@@ -1,6 +1,8 @@
 import { ErrorCode, ForbiddenError, InvalidCredentialsError, InvalidPayloadError, isDirectusError, } from '@directus/errors';
 import express from 'express';
 import Joi from 'joi';
+import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
+import { getDatabase } from '../database/index.js';
 import checkRateLimit from '../middleware/rate-limiter-registration.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
@@ -11,8 +13,6 @@ import { TFAService } from '../services/tfa.js';
 import { UsersService } from '../services/users.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
-import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
-import { getDatabase } from '../database/index.js';
 const router = express.Router();
 router.use(useCollection('directus_users'));
 router.post('/', asyncHandler(async (req, res, next) => {

package/dist/database/helpers/fn/types.js

@@ -1,6 +1,6 @@
-import { DatabaseHelper } from '../types.js';
-import { generateAlias } from '../../run-ast/lib/apply-query/index.js';
 import { applyFilter } from '../../run-ast/lib/apply-query/filter/index.js';
+import { generateRelationalQueryAlias } from '../../run-ast/utils/generate-alias.js';
+import { DatabaseHelper } from '../types.js';
 export class FnHelper extends DatabaseHelper {
     schema;
     constructor(knex, schema) {
@@ -16,7 +16,7 @@ export class FnHelper extends DatabaseHelper {
             throw new Error(`Field ${collectionName}.${column} isn't a nested relational collection`);
         }
         // generate a unique alias for the relation collection, to prevent collisions in self referencing relations
-        const alias = generateAlias();
+        const alias = generateRelationalQueryAlias(table, column, collectionName, options);
         let countQuery = this.knex
             .count('*')
             .from({ [alias]: relation.collection })

package/dist/database/helpers/schema/dialects/cockroachdb.d.ts

@@ -1,10 +1,11 @@
 import type { KNEX_TYPES } from '@directus/constants';
 import { type Knex } from 'knex';
-import type { Options, SortRecord } from '../types.js';
+import type { CreateIndexOptions, Options, SortRecord } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperCockroachDb extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
     constraintName(existingName: string): string;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/dialects/cockroachdb.js

@@ -44,4 +44,17 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
             groupByFields.push(...sortRecords.map(({ alias }) => alias));
         }
     }
+    async createIndex(collection, field, options = {}) {
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        // https://www.cockroachlabs.com/docs/stable/create-index
+        if (options.attemptConcurrentIndex) {
+            return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX CONCURRENTLY ?? ON ?? (??)`, [
+                constraintName,
+                collection,
+                field,
+            ]);
+        }
+        return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
+    }
 }

package/dist/database/helpers/schema/dialects/mssql.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
+import { SchemaHelper, type CreateIndexOptions, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperMSSQL extends SchemaHelper {
     generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
@@ -10,4 +10,5 @@ export declare class SchemaHelperMSSQL extends SchemaHelper {
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
     getColumnNameMaxLength(): number;
     getTableNameMaxLength(): number;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/dialects/mssql.js

@@ -60,4 +60,27 @@ export class SchemaHelperMSSQL extends SchemaHelper {
     getTableNameMaxLength() {
         return 128;
     }
+    async createIndex(collection, field, options = {}) {
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        /*
+        Online index operations are not available in every edition of Microsoft SQL Server.
+        For a list of features that are supported by the editions of SQL Server, see Editions and supported features of SQL Server 2022.
+
+        https://learn.microsoft.com/en-us/sql/sql-server/editions-and-components-of-sql-server-2022?view=sql-server-ver16#rdbms-high-availability
+         */
+        const edition = await this.knex
+            .raw(`SELECT SERVERPROPERTY('edition') AS edition`)
+            .then((data) => data?.[0]?.['edition']);
+        if (options.attemptConcurrentIndex && typeof edition === 'string' && edition.startsWith('Enterprise')) {
+            // https://learn.microsoft.com/en-us/sql/t-sql/statements/create-index-transact-sql?view=sql-server-ver16#online---on--off-
+            return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??) WITH (ONLINE = ON)`, [
+                constraintName,
+                collection,
+                field,
+            ]);
+        }
+        // Fall back to blocking index creation for non-enterprise editions
+        return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
+    }
 }

package/dist/database/helpers/schema/dialects/mysql.d.ts

@@ -1,7 +1,8 @@
 import type { Knex } from 'knex';
-import { SchemaHelper, type SortRecord } from '../types.js';
+import { SchemaHelper, type CreateIndexOptions, type SortRecord } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
     generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/dialects/mysql.js

@@ -54,4 +54,29 @@ export class SchemaHelperMySQL extends SchemaHelper {
             groupByFields.push(...sortRecords.map(({ alias }) => alias));
         }
     }
+    async createIndex(collection, field, options = {}) {
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        const blockingQuery = this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [
+            constraintName,
+            collection,
+            field,
+        ]);
+        if (options.attemptConcurrentIndex) {
+            /*
+            Seems it is not possible to determine whether "ALGORITHM=INPLACE LOCK=NONE" will be supported
+            so we're just going to send it and fall back to blocking index creation on error
+            
+            https://dev.mysql.com/doc/refman/8.4/en/create-index.html#:~:text=engine%20is%20changed.-,Table%20Copying%20and%20Locking%20Options,-ALGORITHM%20and%20LOCK
+            */
+            return this.knex
+                .raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??) ALGORITHM=INPLACE LOCK=NONE`, [
+                constraintName,
+                collection,
+                field,
+            ])
+                .catch(() => blockingQuery);
+        }
+        return blockingQuery;
+    }
 }

package/dist/database/helpers/schema/dialects/oracle.d.ts

@@ -2,7 +2,7 @@ import type { KNEX_TYPES } from '@directus/constants';
 import type { Column } from '@directus/schema';
 import type { Field, RawField, Relation, Type } from '@directus/types';
 import type { Knex } from 'knex';
-import type { Options, SortRecord, Sql } from '../types.js';
+import type { CreateIndexOptions, Options, SortRecord, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperOracle extends SchemaHelper {
     generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
@@ -20,4 +20,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
     getColumnNameMaxLength(): number;
     getTableNameMaxLength(): number;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/dialects/oracle.js

@@ -102,4 +102,17 @@ export class SchemaHelperOracle extends SchemaHelper {
     getTableNameMaxLength() {
         return 128;
     }
+    async createIndex(collection, field, options = {}) {
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        if (options.attemptConcurrentIndex) {
+            // https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-INDEX.html#GUID-1F89BBC0-825F-4215-AF71-7588E31D8BFE__GUID-041E5429-065B-43D5-AC7F-66810140842C
+            return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??) ONLINE`, [
+                constraintName,
+                collection,
+                field,
+            ]);
+        }
+        return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
+    }
 }

package/dist/database/helpers/schema/dialects/postgres.d.ts

@@ -1,7 +1,8 @@
 import type { Knex } from 'knex';
-import { SchemaHelper, type SortRecord } from '../types.js';
+import { SchemaHelper, type CreateIndexOptions, type SortRecord } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
     generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/dialects/postgres.js

@@ -38,4 +38,17 @@ export class SchemaHelperPostgres extends SchemaHelper {
             groupByFields.push(...sortRecords.map(({ alias }) => alias));
         }
     }
+    async createIndex(collection, field, options = {}) {
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        // https://www.postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY
+        if (options.attemptConcurrentIndex) {
+            return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX CONCURRENTLY ?? ON ?? (??)`, [
+                constraintName,
+                collection,
+                field,
+            ]);
+        }
+        return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
+    }
 }

package/dist/database/helpers/schema/types.d.ts

@@ -16,6 +16,10 @@ export type SortRecord = {
     alias: string;
     column: Knex.Raw;
 };
+export type CreateIndexOptions = {
+    attemptConcurrentIndex?: boolean;
+    unique?: boolean;
+};
 export declare abstract class SchemaHelper extends DatabaseHelper {
     isOneOfClients(clients: DatabaseClient[]): boolean;
     changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
@@ -41,4 +45,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
     getColumnNameMaxLength(): number;
     getTableNameMaxLength(): number;
+    createIndex(collection: string, field: string, options?: CreateIndexOptions): Promise<Knex.SchemaBuilder>;
 }

package/dist/database/helpers/schema/types.js

@@ -118,4 +118,10 @@ export class SchemaHelper extends DatabaseHelper {
     getTableNameMaxLength() {
         return 64;
     }
+    async createIndex(collection, field, options = {}) {
+        // fall back to concurrent index creation
+        const isUnique = Boolean(options.unique);
+        const constraintName = this.generateIndexName(isUnique ? 'unique' : 'index', collection, field);
+        return this.knex.raw(`CREATE ${isUnique ? 'UNIQUE ' : ''}INDEX ?? ON ?? (??)`, [constraintName, collection, field]);
+    }
 }

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/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 = [];