@directus/api 26.0.0 → 27.0.0

package/dist/cli/utils/create-db-connection.js

@@ -2,7 +2,6 @@ import knex from 'knex';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
-import { promisify } from 'util';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export default function createDBConnection(client, credentials) {
     let connection = {};
@@ -46,10 +45,9 @@ export default function createDBConnection(client, credentials) {
         knexConfig.useNullAsDefault = true;
     }
     if (client === 'cockroachdb') {
-        knexConfig.pool.afterCreate = async (conn, callback) => {
-            const run = promisify(conn.query.bind(conn));
-            await run('SET serial_normalization = "sql_sequence"');
-            await run('SET default_int_size = 4');
+        knexConfig.pool.afterCreate = (conn, callback) => {
+            conn.query('SET serial_normalization = "sql_sequence"');
+            conn.query('SET default_int_size = 4');
             callback(null, conn);
         };
     }

package/dist/controllers/files.js

@@ -77,7 +77,7 @@ export const multipartHandler = (req, res, next) => {
                 payload.title = formatTitle(path.parse(filename).name);
             }
         }
-        payload.filename_download = filename;
+        payload.filename_download ||= filename;
         const payloadWithRequiredFields = {
             ...payload,
             type: mimeType,

package/dist/database/get-ast-from-query/lib/convert-wildcards.js

@@ -1,6 +1,6 @@
+import { getRelation } from '@directus/utils';
 import { cloneDeep } from 'lodash-es';
 import { fetchAllowedFields } from '../../../permissions/modules/fetch-allowed-fields/fetch-allowed-fields.js';
-import { getRelation } from '../utils/get-relation.js';
 export async function convertWildcards(options, context) {
     const fields = cloneDeep(options.fields);
     const fieldsInCollection = Object.entries(context.schema.collections[options.parentCollection].fields).map(([name]) => name);
@@ -47,7 +47,7 @@ export async function convertWildcards(options, context) {
                     const isMany = relation.collection === options.parentCollection;
                     return isMany ? relation.field : relation.meta?.one_field;
                 })
-                : allowedFields.filter((fieldKey) => !!getRelation(context.schema, options.parentCollection, fieldKey));
+                : allowedFields.filter((fieldKey) => !!getRelation(context.schema.relations, options.parentCollection, fieldKey));
             const nonRelationalFields = allowedFields.filter((fieldKey) => relationalFields.includes(fieldKey) === false);
             const aliasFields = Object.keys(options.query.alias ?? {}).map((fieldKey) => {
                 const name = options.query.alias[fieldKey];

package/dist/database/get-ast-from-query/lib/parse-fields.js

@@ -1,4 +1,5 @@
 import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+import { getRelation } from '@directus/utils';
 import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
@@ -6,7 +7,6 @@ import { getRelationType } from '../../../utils/get-relation-type.js';
 import { getAllowedSort } from '../utils/get-allowed-sort.js';
 import { getDeepQuery } from '../utils/get-deep-query.js';
 import { getRelatedCollection } from '../utils/get-related-collection.js';
-import { getRelation } from '../utils/get-relation.js';
 import { convertWildcards } from './convert-wildcards.js';
 export async function parseFields(options, context) {
     let { fields } = options;
@@ -108,7 +108,7 @@ export async function parseFields(options, context) {
             fieldName = options.query.alias[fieldKey];
         }
         const relatedCollection = getRelatedCollection(context.schema, options.parentCollection, fieldName);
-        const relation = getRelation(context.schema, options.parentCollection, fieldName);
+        const relation = getRelation(context.schema.relations, options.parentCollection, fieldName);
         if (!relation)
             continue;
         const relationType = getRelationType({

package/dist/database/get-ast-from-query/utils/get-related-collection.js

@@ -1,6 +1,6 @@
-import { getRelation } from './get-relation.js';
+import { getRelation } from '@directus/utils';
 export function getRelatedCollection(schema, collection, field) {
-    const relation = getRelation(schema, collection, field);
+    const relation = getRelation(schema.relations, collection, field);
     if (!relation)
         return null;
     if (relation.collection === collection && relation.field === field) {

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

@@ -1,5 +1,6 @@
-import { applyFilter, generateAlias } from '../../../utils/apply-query.js';
 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';
 export class FnHelper extends DatabaseHelper {
     schema;
     constructor(knex, schema) {

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

@@ -8,4 +8,6 @@ export declare class SchemaHelperMSSQL extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
     prepQueryParams(queryParams: Sql): Sql;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
+    getColumnNameMaxLength(): number;
+    getTableNameMaxLength(): number;
 }

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

@@ -54,4 +54,10 @@ export class SchemaHelperMSSQL extends SchemaHelper {
             groupByFields.push(...sortRecords.map(({ column }) => column));
         }
     }
+    getColumnNameMaxLength() {
+        return 128;
+    }
+    getTableNameMaxLength() {
+        return 128;
+    }
 }

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

@@ -2,7 +2,6 @@ import type { Knex } from 'knex';
 import { SchemaHelper, type SortRecord } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
     generateIndexName(type: 'unique' | 'foreign' | 'index', collection: string, fields: string | string[]): string;
-    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
     getDatabaseSize(): Promise<number | null>;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasRelationalSort: boolean): void;
 }

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

@@ -1,22 +1,11 @@
 import { useEnv } from '@directus/env';
 import { getDefaultIndexName } from '../../../../utils/get-default-index-name.js';
-import { getDatabaseVersion } from '../../../index.js';
 import { SchemaHelper } from '../types.js';
 const env = useEnv();
 export class SchemaHelperMySQL extends SchemaHelper {
     generateIndexName(type, collection, fields) {
         return getDefaultIndexName(type, collection, fields, { maxLength: 64 });
     }
-    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
-        if (getDatabaseVersion()?.startsWith('5.7')) {
-            dbQuery.orderByRaw(`?? asc, ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]);
-            dbQuery = knex
-                .select(knex.raw(`??, ( @rank := IF ( @cur_id = deep.${primaryKey}, @rank + 1, 1 ) ) AS directus_row_number, ( @cur_id := deep.${primaryKey} ) AS current_id`, 'deep.*'))
-                .from(knex.raw('? as ??, (SELECT @rank := 0,  @cur_id := null) vars', [dbQuery, 'deep']));
-            return dbQuery;
-        }
-        return super.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
-    }
     async getDatabaseSize() {
         try {
             const result = (await this.knex

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

@@ -18,4 +18,6 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     prepQueryParams(queryParams: Sql): Sql;
     prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
+    getColumnNameMaxLength(): number;
+    getTableNameMaxLength(): number;
 }

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

@@ -96,4 +96,10 @@ export class SchemaHelperOracle extends SchemaHelper {
             groupByFields.push(...sortRecords.map(({ column }) => column));
         }
     }
+    getColumnNameMaxLength() {
+        return 128;
+    }
+    getTableNameMaxLength() {
+        return 128;
+    }
 }

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

@@ -32,7 +32,6 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     castA2oPrimaryKey(): string;
-    applyMultiRelationalSort(knex: Knex, dbQuery: Knex.QueryBuilder, table: string, primaryKey: string, orderByString: string, orderByFields: Knex.Raw[]): Knex.QueryBuilder;
     formatUUID(uuid: string): string;
     /**
      * @returns Size of the database in bytes
@@ -41,4 +40,6 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
     prepQueryParams(queryParams: Sql): Sql;
     prepBindings(bindings: Knex.Value[]): any;
     addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasRelationalSort: boolean): void;
+    getColumnNameMaxLength(): number;
+    getTableNameMaxLength(): number;
 }

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

@@ -94,10 +94,6 @@ export class SchemaHelper extends DatabaseHelper {
     castA2oPrimaryKey() {
         return 'CAST(?? AS CHAR(255))';
     }
-    applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields) {
-        dbQuery.rowNumber(knex.ref('directus_row_number').toQuery(), knex.raw(`partition by ?? order by ${orderByString}`, [`${table}.${primaryKey}`, ...orderByFields]));
-        return dbQuery;
-    }
     formatUUID(uuid) {
         return uuid; // no-op by default
     }
@@ -116,4 +112,10 @@ export class SchemaHelper extends DatabaseHelper {
     addInnerSortFieldsToGroupBy(_groupByFields, _sortRecords, _hasRelationalSort) {
         // no-op by default
     }
+    getColumnNameMaxLength() {
+        return 64;
+    }
+    getTableNameMaxLength() {
+        return 64;
+    }
 }

package/dist/database/index.d.ts

@@ -4,12 +4,6 @@ import type { DatabaseClient } from '../types/index.js';
 export default getDatabase;
 export declare function getDatabase(): Knex;
 export declare function getSchemaInspector(database?: Knex): SchemaInspector;
-/**
- * Get database version. Value currently exists for MySQL only.
- *
- * @returns Cached database version
- */
-export declare function getDatabaseVersion(): string | null;
 export declare function hasDatabaseConnection(database?: Knex): Promise<boolean>;
 export declare function validateDatabaseConnection(database?: Knex): Promise<void>;
 export declare function getDatabaseClient(database?: Knex): DatabaseClient;

package/dist/database/index.js

@@ -3,12 +3,11 @@ import { createInspector } from '@directus/schema';
 import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import knex from 'knex';
-import { isArray, merge } from 'lodash-es';
+import { isArray, merge, toArray } from 'lodash-es';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import path from 'path';
 import { performance } from 'perf_hooks';
-import { promisify } from 'util';
 import { getExtensionsPath } from '../extensions/lib/get-extensions-path.js';
 import { useLogger } from '../logger/index.js';
 import { useMetrics } from '../metrics/index.js';
@@ -17,7 +16,6 @@ import { validateEnv } from '../utils/validate-env.js';
 import { getHelpers } from './helpers/index.js';
 let database = null;
 let inspector = null;
-let databaseVersion = null;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export default getDatabase;
 export function getDatabase() {
@@ -92,29 +90,27 @@ export function getDatabase() {
     };
     if (client === 'sqlite3') {
         knexConfig.useNullAsDefault = true;
-        poolConfig.afterCreate = async (conn, callback) => {
+        poolConfig.afterCreate = (conn, callback) => {
             logger.trace('Enabling SQLite Foreign Keys support...');
-            const run = promisify(conn.run.bind(conn));
-            await run('PRAGMA foreign_keys = ON');
+            conn.run('PRAGMA foreign_keys = ON');
             callback(null, conn);
         };
     }
     if (client === 'cockroachdb') {
-        poolConfig.afterCreate = async (conn, callback) => {
+        poolConfig.afterCreate = (conn, callback) => {
             logger.trace('Setting CRDB serial_normalization and default_int_size');
-            const run = promisify(conn.query.bind(conn));
-            await run('SET serial_normalization = "sql_sequence"');
-            await run('SET default_int_size = 4');
+            conn.query('SET serial_normalization = "sql_sequence"');
+            conn.query('SET default_int_size = 4');
             callback(null, conn);
         };
     }
     if (client === 'oracledb') {
-        poolConfig.afterCreate = async (conn, callback) => {
+        poolConfig.afterCreate = (conn, callback) => {
             logger.trace('Setting OracleDB NLS_DATE_FORMAT and NLS_TIMESTAMP_FORMAT');
             // enforce proper ISO standard 2024-12-10T10:54:00.123Z for datetime/timestamp
-            await conn.executeAsync('ALTER SESSION SET NLS_TIMESTAMP_FORMAT = \'YYYY-MM-DD"T"HH24:MI:SS.FF3"Z"\'');
+            conn.execute('ALTER SESSION SET NLS_TIMESTAMP_FORMAT = \'YYYY-MM-DD"T"HH24:MI:SS.FF3"Z"\'');
             // enforce 2024-12-10 date formet
-            await conn.executeAsync("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD'");
+            conn.execute("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD'");
             callback(null, conn);
         };
     }
@@ -123,13 +119,6 @@ export function getDatabase() {
         if (isObject(knexConfig.connection))
             delete knexConfig.connection['filename'];
         Object.assign(knexConfig, { client: 'mysql2' });
-        poolConfig.afterCreate = async (conn, callback) => {
-            logger.trace('Retrieving database version');
-            const run = promisify(conn.query.bind(conn));
-            const version = await run('SELECT @@version;');
-            databaseVersion = version[0]['@@version'];
-            callback(null, conn);
-        };
     }
     if (client === 'mssql') {
         // This brings MS SQL in line with the other DB vendors. We shouldn't do any automatic
@@ -173,14 +162,6 @@ export function getSchemaInspector(database) {
     inspector = createInspector(database);
     return inspector;
 }
-/**
- * Get database version. Value currently exists for MySQL only.
- *
- * @returns Cached database version
- */
-export function getDatabaseVersion() {
-    return databaseVersion;
-}
 export async function hasDatabaseConnection(database) {
     database = database ?? getDatabase();
     try {
@@ -296,8 +277,11 @@ async function validateDatabaseCharset(database) {
             .select({ table_name: 'TABLE_NAME', name: 'COLUMN_NAME', collation: 'COLLATION_NAME' })
             .where({ TABLE_SCHEMA: env['DB_DATABASE'] })
             .whereNot({ COLLATION_NAME: collation });
+        const excludedTables = toArray(env['DB_EXCLUDE_TABLES']);
         let inconsistencies = '';
         for (const table of tables) {
+            if (excludedTables.includes(table.name))
+                continue;
             const tableColumns = columns.filter((column) => column.table_name === table.name);
             const tableHasInvalidCollation = table.collation !== collation;
             if (tableHasInvalidCollation || tableColumns.length > 0) {

package/dist/database/migrations/20210225A-add-relations-sort-field.js

@@ -1,7 +1,9 @@
 import { parseJSON } from '@directus/utils';
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.alterTable('directus_relations', (table) => {
-        table.string('sort_field');
+        table.string('sort_field', helpers.schema.getColumnNameMaxLength());
     });
     const fieldsWithSort = await knex
         .select('collection', 'field', 'options')

package/dist/database/migrations/20210510A-restructure-relations.js

@@ -1,27 +1,27 @@
 import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
-    const helper = getHelpers(knex).schema;
+    const helper = getHelpers(knex);
     await knex.schema.alterTable('directus_relations', (table) => {
         table.dropColumns('many_primary', 'one_primary');
         table.string('one_deselect_action').defaultTo('nullify');
     });
     await knex('directus_relations').update({ one_deselect_action: 'nullify' });
-    await helper.changeToType('directus_relations', 'sort_field', 'string', {
-        length: 64,
+    await helper.schema.changeToType('directus_relations', 'sort_field', 'string', {
+        length: helper.schema.getColumnNameMaxLength(),
     });
-    await helper.changeToType('directus_relations', 'one_deselect_action', 'string', {
+    await helper.schema.changeToType('directus_relations', 'one_deselect_action', 'string', {
         nullable: false,
         default: 'nullify',
     });
 }
 export async function down(knex) {
-    const helper = getHelpers(knex).schema;
-    await helper.changeToType('directus_relations', 'sort_field', 'string', {
+    const helper = getHelpers(knex);
+    await helper.schema.changeToType('directus_relations', 'sort_field', 'string', {
         length: 255,
     });
     await knex.schema.alterTable('directus_relations', (table) => {
         table.dropColumn('one_deselect_action');
-        table.string('many_primary', 64);
-        table.string('one_primary', 64);
+        table.string('many_primary', helper.schema.getColumnNameMaxLength());
+        table.string('one_primary', helper.schema.getColumnNameMaxLength());
     });
 }

package/dist/database/migrations/20210924A-add-collection-organization.js

@@ -1,7 +1,12 @@
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.alterTable('directus_collections', (table) => {
         table.integer('sort');
-        table.string('group', 64).references('collection').inTable('directus_collections');
+        table
+            .string('group', helpers.schema.getTableNameMaxLength())
+            .references('collection')
+            .inTable('directus_collections');
         table.string('collapse').defaultTo('open').notNullable();
     });
 }

package/dist/database/migrations/20210927A-replace-fields-group.js

@@ -1,5 +1,7 @@
 import { uniq } from 'lodash-es';
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     const groupsInUse = await knex.select('id', 'group').from('directus_fields').whereNotNull('group');
     const groupIDs = uniq(groupsInUse.map(({ group }) => group));
     const groupFields = await knex.select('id', 'field').from('directus_fields').whereIn('id', groupIDs);
@@ -14,7 +16,7 @@ export async function up(knex) {
         table.dropColumn('group');
     });
     await knex.schema.alterTable('directus_fields', (table) => {
-        table.string('group', 64);
+        table.string('group', helpers.schema.getColumnNameMaxLength());
     });
     for (const { id, group } of groupsInUse) {
         await knex('directus_fields')

package/dist/database/migrations/20211118A-add-notifications.js

@@ -1,4 +1,6 @@
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.createTable('directus_notifications', (table) => {
         table.increments();
         table.timestamp('timestamp').notNullable();
@@ -7,7 +9,7 @@ export async function up(knex) {
         table.uuid('sender').notNullable().references('id').inTable('directus_users');
         table.string('subject').notNullable();
         table.text('message');
-        table.string('collection', 64);
+        table.string('collection', helpers.schema.getTableNameMaxLength());
         table.string('item');
     });
     await knex.schema.alterTable('directus_users', (table) => {

package/dist/database/migrations/20211211A-add-shares.js

@@ -1,8 +1,14 @@
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.createTable('directus_shares', (table) => {
         table.uuid('id').primary().notNullable();
         table.string('name');
-        table.string('collection', 64).references('collection').inTable('directus_collections').onDelete('CASCADE');
+        table
+            .string('collection', helpers.schema.getTableNameMaxLength())
+            .references('collection')
+            .inTable('directus_collections')
+            .onDelete('CASCADE');
         table.string('item');
         table.uuid('role').references('id').inTable('directus_roles').onDelete('CASCADE');
         table.string('password');

package/dist/database/migrations/20230823A-add-content-versioning.js

@@ -1,10 +1,12 @@
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.createTable('directus_versions', (table) => {
         table.uuid('id').primary().notNullable();
         table.string('key', 64).notNullable();
         table.string('name');
         table
-            .string('collection', 64)
+            .string('collection', helpers.schema.getTableNameMaxLength())
             .notNullable()
             .references('collection')
             .inTable('directus_collections')

package/dist/database/migrations/20240909A-separate-comments.js

@@ -1,8 +1,10 @@
 import { Action } from '@directus/constants';
+import { getHelpers } from '../helpers/index.js';
 export async function up(knex) {
+    const helpers = getHelpers(knex);
     await knex.schema.createTable('directus_comments', (table) => {
         table.uuid('id').primary().notNullable();
-        table.string('collection', 64).notNullable();
+        table.string('collection', helpers.schema.getTableNameMaxLength()).notNullable();
         table.string('item').notNullable();
         table.text('comment').notNullable();
         table.timestamp('date_created').defaultTo(knex.fn.now());

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

@@ -0,0 +1,54 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../../utils/get-column-path.js';
+/**
+ * Apply a given filter object to the Knex QueryBuilder instance.
+ *
+ * Relational nested filters, like the following example:
+ *
+ * ```json
+ * // Fetch pages that have articles written by Rijk
+ *
+ * {
+ *   "articles": {
+ *     "author": {
+ *       "name": {
+ *         "_eq": "Rijk"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * are handled by joining the nested tables, and using a where statement on the top level on the
+ * nested field through the join. This allows us to filter the top level items based on nested data.
+ * The where on the root is done with a subquery to prevent duplicates, any nested joins are done
+ * with aliases to prevent naming conflicts.
+ *
+ * The output SQL for the above would look something like:
+ *
+ * ```sql
+ * SELECT *
+ * FROM pages
+ * WHERE
+ *   pages.id in (
+ *     SELECT articles.page_id AS page_id
+ *     FROM articles
+ *     LEFT JOIN authors AS xviqp ON articles.author = xviqp.id
+ *     WHERE xviqp.name = 'Rijk'
+ *   )
+ * ```
+ */
+type AddJoinProps = {
+    path: string[];
+    collection: string;
+    aliasMap: AliasMap;
+    rootQuery: Knex.QueryBuilder;
+    schema: SchemaOverview;
+    knex: Knex;
+};
+export declare function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }: AddJoinProps): {
+    hasMultiRelational: boolean;
+    isJoinAdded: boolean;
+};
+export {};

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

@@ -0,0 +1,86 @@
+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';
+export function addJoin({ path, collection, aliasMap, rootQuery, schema, knex }) {
+    let hasMultiRelational = false;
+    let isJoinAdded = false;
+    path = clone(path);
+    followRelation(path);
+    return { hasMultiRelational, isJoinAdded };
+    function followRelation(pathParts, parentCollection = collection, parentFields) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = getRelationInfo(schema.relations, parentCollection, pathRoot);
+        if (!relation) {
+            return;
+        }
+        const existingAlias = parentFields
+            ? aliasMap[`${parentFields}.${pathParts[0]}`]?.alias
+            : aliasMap[pathParts[0]]?.alias;
+        if (!existingAlias) {
+            const alias = generateAlias();
+            const aliasKey = parentFields ? `${parentFields}.${pathParts[0]}` : pathParts[0];
+            const aliasedParentCollection = aliasMap[parentFields ?? '']?.alias || parentCollection;
+            aliasMap[aliasKey] = { alias, collection: '' };
+            if (relationType === 'm2o') {
+                rootQuery.leftJoin({ [alias]: relation.related_collection }, `${aliasedParentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
+                aliasMap[aliasKey].collection = relation.related_collection;
+                isJoinAdded = true;
+            }
+            else if (relationType === 'a2o') {
+                const pathScope = pathParts[0].split(':')[1];
+                if (!pathScope) {
+                    throw new InvalidQueryError({
+                        reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
+                    });
+                }
+                rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
+                    joinClause
+                        .onVal(`${aliasedParentCollection}.${relation.meta.one_collection_field}`, '=', pathScope)
+                        .andOn(`${aliasedParentCollection}.${relation.field}`, '=', knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${alias}.${schema.collections[pathScope].primary}`));
+                });
+                aliasMap[aliasKey].collection = pathScope;
+                isJoinAdded = true;
+            }
+            else if (relationType === 'o2a') {
+                rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                    joinClause
+                        .onVal(`${alias}.${relation.meta.one_collection_field}`, '=', parentCollection)
+                        .andOn(`${alias}.${relation.field}`, '=', knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), `${aliasedParentCollection}.${schema.collections[parentCollection].primary}`));
+                });
+                aliasMap[aliasKey].collection = relation.collection;
+                hasMultiRelational = true;
+                isJoinAdded = true;
+            }
+            else if (relationType === 'o2m') {
+                rootQuery.leftJoin({ [alias]: relation.collection }, `${aliasedParentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
+                aliasMap[aliasKey].collection = relation.collection;
+                hasMultiRelational = true;
+                isJoinAdded = true;
+            }
+        }
+        let parent;
+        if (relationType === 'm2o') {
+            parent = relation.related_collection;
+        }
+        else if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new InvalidQueryError({
+                    reason: `You have to provide a collection scope when sorting or filtering on a many-to-any item`,
+                });
+            }
+            parent = pathScope;
+        }
+        else {
+            parent = relation.collection;
+        }
+        if (pathParts.length > 1) {
+            followRelation(pathParts.slice(1), parent, `${parentFields ? parentFields + '.' : ''}${pathParts[0]}`);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { Aggregate, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function applyAggregate(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string, hasJoins: boolean): void;

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

@@ -0,0 +1,24 @@
+export function applyAggregate(schema, dbQuery, aggregate, collection, hasJoins) {
+    for (const [operation, fields] of Object.entries(aggregate)) {
+        if (!fields)
+            continue;
+        for (const field of fields) {
+            if (operation === 'countAll') {
+                dbQuery.count('*', { as: 'countAll' });
+                continue;
+            }
+            if (operation === 'count' && field === '*') {
+                dbQuery.count('*', { as: 'count' });
+                continue;
+            }
+            if (operation === 'countDistinct' && !hasJoins && schema.collections[collection]?.primary === field) {
+                // Optimize to count as primary keys are unique
+                dbQuery.count(`${collection}.${field}`, { as: `countDistinct->${field}` });
+                continue;
+            }
+            if (['count', 'countDistinct', 'avg', 'avgDistinct', 'sum', 'sumDistinct', 'min', 'max'].includes(operation)) {
+                dbQuery[operation](`${collection}.${field}`, { as: `${operation}->${field}` });
+            }
+        }
+    }
+}