@directus/api 22.1.0 → 22.2.0

package/dist/app.js

@@ -125,7 +125,7 @@ export default async function createApp() {
                 'https://avatars.githubusercontent.com',
             ],
             mediaSrc: ["'self'"],
-            connectSrc: ["'self'", 'https://*'],
+            connectSrc: ["'self'", 'https://*', 'wss://*'],
         },
     }, getConfigFromEnv('CONTENT_SECURITY_POLICY_'))));
     if (env['HSTS_ENABLED']) {

package/dist/cache.d.ts

@@ -13,7 +13,7 @@ export declare function clearSystemCache(opts?: {
 }): Promise<void>;
 export declare function setSystemCache(key: string, value: any, ttl?: number): Promise<void>;
 export declare function getSystemCache(key: string): Promise<Record<string, any>>;
-export declare function setSchemaCache(schema: SchemaOverview): Promise<void>;
-export declare function getSchemaCache(): Promise<SchemaOverview | undefined>;
+export declare function setLocalSchemaCache(schema: SchemaOverview): Promise<void>;
+export declare function getLocalSchemaCache(): Promise<SchemaOverview | undefined>;
 export declare function setCacheValue(cache: Keyv, key: string, value: Record<string, any> | Record<string, any>[], ttl?: number): Promise<void>;
 export declare function getCacheValue(cache: Keyv, key: string): Promise<any>;

package/dist/cache.js

@@ -75,11 +75,11 @@ export async function getSystemCache(key) {
     const { systemCache } = getCache();
     return await getCacheValue(systemCache, key);
 }
-export async function setSchemaCache(schema) {
+export async function setLocalSchemaCache(schema) {
     const { localSchemaCache } = getCache();
     await localSchemaCache.set('schema', schema);
 }
-export async function getSchemaCache() {
+export async function getLocalSchemaCache() {
     const { localSchemaCache } = getCache();
     return await localSchemaCache.get('schema');
 }

package/dist/constants.d.ts

@@ -23,3 +23,4 @@ export declare const RESUMABLE_UPLOADS: {
     EXPIRATION_TIME: number;
     SCHEDULE: string;
 };
+export declare const ALLOWED_DB_DEFAULT_FUNCTIONS: string[];

package/dist/constants.js

@@ -87,3 +87,4 @@ export const RESUMABLE_UPLOADS = {
     EXPIRATION_TIME: getMilliseconds(env['TUS_UPLOAD_EXPIRATION'], 600_000 /* 10min */),
     SCHEDULE: String(env['TUS_CLEANUP_SCHEDULE']),
 };
+export const ALLOWED_DB_DEFAULT_FUNCTIONS = ['gen_random_uuid()'];

package/dist/database/get-ast-from-query/get-ast-from-query.js

@@ -2,8 +2,8 @@
  * Generate an AST based on a given collection and query
  */
 import { cloneDeep, uniq } from 'lodash-es';
-import { fetchAllowedFields } from '../../permissions/modules/fetch-allowed-fields/fetch-allowed-fields.js';
 import { parseFields } from './lib/parse-fields.js';
+import { getAllowedSort } from './utils/get-allowed-sort.js';
 export async function getAstFromQuery(options, context) {
     options.query = cloneDeep(options.query);
     const ast = {
@@ -36,36 +36,7 @@ export async function getAstFromQuery(options, context) {
     // Prevent fields/deep from showing up in the query object in further use
     delete options.query.fields;
     delete options.query.deep;
-    if (!options.query.sort) {
-        // We'll default to the primary key for the standard sort output
-        let sortField = context.schema.collections[options.collection].primary;
-        // If a custom manual sort field is configured, use that
-        if (context.schema.collections[options.collection]?.sortField) {
-            sortField = context.schema.collections[options.collection].sortField;
-        }
-        if (options.accountability && options.accountability.admin === false) {
-            // Verify that the user has access to the sort field
-            const allowedFields = await fetchAllowedFields({
-                collection: options.collection,
-                action: 'read',
-                accountability: options.accountability,
-            }, context);
-            if (allowedFields.length === 0) {
-                sortField = null;
-            }
-            else if (allowedFields.includes('*') === false && allowedFields.includes(sortField) === false) {
-                // If the sort field is not allowed, default to the first allowed field
-                sortField = allowedFields[0];
-            }
-        }
-        // When group by is used, default to the first column provided in the group by clause
-        if (options.query.group?.[0]) {
-            sortField = options.query.group[0];
-        }
-        if (sortField) {
-            options.query.sort = [sortField];
-        }
-    }
+    options.query.sort ??= await getAllowedSort(options, context);
     // When no group by is supplied, but an aggregate function is used, only a single row will be
     // returned. In those cases, we'll ignore the sort field altogether
     if (options.query.aggregate && Object.keys(options.query.aggregate).length && !options.query.group?.[0]) {

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

@@ -1,6 +1,6 @@
 import type { Accountability, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { FieldNode, FunctionFieldNode, NestedCollectionNode } from '../../../types/index.js';
+import type { FieldNode, FunctionFieldNode, NestedCollectionNode, O2MNode } from '../../../types/index.js';
 export interface ParseFieldsOptions {
     accountability: Accountability | null;
     parentCollection: string;
@@ -13,3 +13,4 @@ export interface ParseFieldsContext {
     knex: Knex;
 }
 export declare function parseFields(options: ParseFieldsOptions, context: ParseFieldsContext): Promise<[] | (NestedCollectionNode | FieldNode | FunctionFieldNode)[]>;
+export declare function isO2MNode(node: NestedCollectionNode | null): node is O2MNode;

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

@@ -3,6 +3,7 @@ import { isEmpty } from 'lodash-es';
 import { fetchPermissions } from '../../../permissions/lib/fetch-permissions.js';
 import { fetchPolicies } from '../../../permissions/lib/fetch-policies.js';
 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';
@@ -119,7 +120,16 @@ export async function parseFields(options, context) {
             continue;
         let child = null;
         if (relationType === 'a2o') {
-            const allowedCollections = relation.meta.one_allowed_collections;
+            let allowedCollections = relation.meta.one_allowed_collections;
+            if (options.accountability && options.accountability.admin === false && policies) {
+                const permissions = await fetchPermissions({
+                    action: 'read',
+                    collections: allowedCollections,
+                    policies: policies,
+                    accountability: options.accountability,
+                }, context);
+                allowedCollections = allowedCollections.filter((collection) => permissions.some((permission) => permission.collection === collection));
+            }
             child = {
                 type: 'a2o',
                 names: allowedCollections,
@@ -181,8 +191,13 @@ export async function parseFields(options, context) {
                 cases: [],
                 whenCase: [],
             };
-            if (relationType === 'o2m' && !child.query.sort) {
-                child.query.sort = [relation.meta?.sort_field || context.schema.collections[relation.collection].primary];
+            if (isO2MNode(child) && !child.query.sort) {
+                child.query.sort = await getAllowedSort({ collection: relation.collection, relation, accountability: options.accountability }, context);
+            }
+            if (isO2MNode(child) && child.query.group && child.query.group[0] !== relation.field) {
+                // If a group by is used, the result needs to be grouped by the foreign key of the relation first, so results
+                // are correctly grouped under the foreign key when extracting the grouped results from the nested queries.
+                child.query.group.unshift(relation.field);
             }
         }
         if (child) {
@@ -198,3 +213,6 @@ export async function parseFields(options, context) {
         return true;
     });
 }
+export function isO2MNode(node) {
+    return !!node && node.type === 'o2m';
+}

package/dist/database/get-ast-from-query/utils/get-allowed-sort.d.ts

@@ -0,0 +1,9 @@
+import type { Accountability, Query, Relation } from '@directus/types';
+import type { Context } from '../../../permissions/types.js';
+export type GetAllowedSortFieldOptions = {
+    collection: string;
+    accountability: Accountability | null;
+    query?: Query;
+    relation?: Relation;
+};
+export declare function getAllowedSort(options: GetAllowedSortFieldOptions, context: Context): Promise<string[] | null>;

package/dist/database/get-ast-from-query/utils/get-allowed-sort.js

@@ -0,0 +1,35 @@
+import { fetchAllowedFields } from '../../../permissions/modules/fetch-allowed-fields/fetch-allowed-fields.js';
+export async function getAllowedSort(options, context) {
+    // We'll default to the primary key for the standard sort output
+    let sortField = context.schema.collections[options.collection].primary;
+    // If a custom manual sort field is configured, use that
+    if (context.schema.collections[options.collection]?.sortField) {
+        sortField = context.schema.collections[options.collection].sortField;
+    }
+    // If a sort field is defined on the relation, use that
+    if (options.relation?.meta?.sort_field) {
+        sortField = options.relation.meta.sort_field;
+    }
+    if (options.accountability && options.accountability.admin === false) {
+        // Verify that the user has access to the sort field
+        const allowedFields = await fetchAllowedFields({
+            collection: options.collection,
+            action: 'read',
+            accountability: options.accountability,
+        }, context);
+        if (allowedFields.length === 0) {
+            sortField = null;
+        }
+        else if (allowedFields.includes('*') === false && allowedFields.includes(sortField) === false) {
+            // If the sort field is not allowed, default to the first allowed field
+            sortField = allowedFields[0];
+        }
+    }
+    // When group by is used, default to the first column provided in the group by clause
+    if (options.query?.group?.[0]) {
+        sortField = options.query.group[0];
+    }
+    if (sortField)
+        return [sortField];
+    return null;
+}

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

@@ -1,11 +1,14 @@
-import type { Filter, Query, SchemaOverview } from '@directus/types';
+import type { Filter, Permission, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import { DatabaseHelper } from '../types.js';
 export type FnHelperOptions = {
     type: string | undefined;
-    query: Query | undefined;
-    cases: Filter[] | undefined;
     originalCollectionName: string | undefined;
+    relationalCountOptions: {
+        query: Query;
+        cases: Filter[];
+        permissions: Permission[];
+    } | undefined;
 };
 export declare abstract class FnHelper extends DatabaseHelper {
     protected schema: SchemaOverview;

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

@@ -20,7 +20,7 @@ export class FnHelper extends DatabaseHelper {
             .count('*')
             .from({ [alias]: relation.collection })
             .where(this.knex.raw(`??.??`, [alias, relation.field]), '=', this.knex.raw(`??.??`, [table, currentPrimary]));
-        if (options?.query?.filter) {
+        if (options?.relationalCountOptions?.query.filter) {
             // set the newly aliased collection in the alias map as the default parent collection, indicated by '', for any nested filters
             const aliasMap = {
                 '': {
@@ -28,7 +28,7 @@ export class FnHelper extends DatabaseHelper {
                     collection: relation.collection,
                 },
             };
-            countQuery = applyFilter(this.knex, this.schema, countQuery, options.query.filter, relation.collection, aliasMap, options.cases ?? []).query;
+            countQuery = applyFilter(this.knex, this.schema, countQuery, options.relationalCountOptions.query.filter, relation.collection, aliasMap, options.relationalCountOptions.cases, options.relationalCountOptions.permissions).query;
         }
         return this.knex.raw('(' + countQuery.toQuery() + ')');
     }

package/dist/database/helpers/index.d.ts

@@ -6,12 +6,14 @@ import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
 import * as numberHelpers from './number/index.js';
+import * as nullableUpdateHelper from './nullable-update/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
     st: geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.mysql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
     schema: schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.mysql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle | schemaHelpers.redshift;
     sequence: sequenceHelpers.mysql | sequenceHelpers.postgres;
     number: numberHelpers.cockroachdb | numberHelpers.mssql | numberHelpers.postgres | numberHelpers.sqlite | numberHelpers.oracle;
+    nullableUpdate: nullableUpdateHelper.postgres | nullableUpdateHelper.oracle;
 };
 export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.postgres | fnHelpers.mssql | fnHelpers.mysql | fnHelpers.sqlite | fnHelpers.oracle;
 export type Helpers = ReturnType<typeof getHelpers>;

package/dist/database/helpers/index.js

@@ -5,6 +5,7 @@ import * as geometryHelpers from './geometry/index.js';
 import * as schemaHelpers from './schema/index.js';
 import * as sequenceHelpers from './sequence/index.js';
 import * as numberHelpers from './number/index.js';
+import * as nullableUpdateHelper from './nullable-update/index.js';
 export function getHelpers(database) {
     const client = getDatabaseClient(database);
     return {
@@ -13,6 +14,7 @@ export function getHelpers(database) {
         schema: new schemaHelpers[client](database),
         sequence: new sequenceHelpers[client](database),
         number: new numberHelpers[client](database),
+        nullableUpdate: new nullableUpdateHelper[client](database),
     };
 }
 export function getFunctions(database, schema) {

package/dist/database/helpers/nullable-update/dialects/default.d.ts

@@ -0,0 +1,3 @@
+import { NullableFieldUpdateHelper } from '../types.js';
+export declare class NullableFieldUpdateHelperDefault extends NullableFieldUpdateHelper {
+}

package/dist/database/helpers/nullable-update/dialects/default.js

@@ -0,0 +1,3 @@
+import { NullableFieldUpdateHelper } from '../types.js';
+export class NullableFieldUpdateHelperDefault extends NullableFieldUpdateHelper {
+}

package/dist/database/helpers/nullable-update/dialects/oracle.d.ts

@@ -0,0 +1,12 @@
+import type { Column } from '@directus/schema';
+import type { Field, RawField } from '@directus/types';
+import type { Knex } from 'knex';
+import { NullableFieldUpdateHelper } from '../types.js';
+/**
+ * Oracle throws an error when overwriting the nullable option with same value.
+ * Therefore we need to check if the nullable option has changed and only then apply it.
+ * The default value can be set regardless of the previous value.
+ */
+export declare class NullableFieldUpdateHelperOracle extends NullableFieldUpdateHelper {
+    updateNullableValue(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column): void;
+}

package/dist/database/helpers/nullable-update/dialects/oracle.js

@@ -0,0 +1,16 @@
+import { NullableFieldUpdateHelper } from '../types.js';
+/**
+ * Oracle throws an error when overwriting the nullable option with same value.
+ * Therefore we need to check if the nullable option has changed and only then apply it.
+ * The default value can be set regardless of the previous value.
+ */
+export class NullableFieldUpdateHelperOracle extends NullableFieldUpdateHelper {
+    updateNullableValue(column, field, existing) {
+        if (field.schema?.is_nullable === false && existing.is_nullable === true) {
+            column.notNullable();
+        }
+        else if (field.schema?.is_nullable === true && existing.is_nullable === false) {
+            column.nullable();
+        }
+    }
+}

package/dist/database/helpers/nullable-update/index.d.ts

@@ -0,0 +1,7 @@
+export { NullableFieldUpdateHelperOracle as oracle } from './dialects/oracle.js';
+export { NullableFieldUpdateHelperDefault as postgres } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as mysql } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as cockroachdb } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as redshift } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as sqlite } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/nullable-update/index.js

@@ -0,0 +1,7 @@
+export { NullableFieldUpdateHelperOracle as oracle } from './dialects/oracle.js';
+export { NullableFieldUpdateHelperDefault as postgres } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as mysql } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as cockroachdb } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as redshift } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as sqlite } from './dialects/default.js';
+export { NullableFieldUpdateHelperDefault as mssql } from './dialects/default.js';

package/dist/database/helpers/nullable-update/types.d.ts

@@ -0,0 +1,7 @@
+import type { Knex } from 'knex';
+import { DatabaseHelper } from '../types.js';
+import type { Column } from '@directus/schema';
+import type { Field, RawField } from '@directus/types';
+export declare class NullableFieldUpdateHelper extends DatabaseHelper {
+    updateNullableValue(column: Knex.ColumnBuilder, field: RawField | Field, existing: Column): void;
+}

package/dist/database/helpers/nullable-update/types.js

@@ -0,0 +1,12 @@
+import { DatabaseHelper } from '../types.js';
+export class NullableFieldUpdateHelper extends DatabaseHelper {
+    updateNullableValue(column, field, existing) {
+        const isNullable = field.schema?.is_nullable ?? existing?.is_nullable ?? true;
+        if (isNullable) {
+            column.nullable();
+        }
+        else {
+            column.notNullable();
+        }
+    }
+}

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

@@ -1,9 +1,11 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Options, Sql } from '../types.js';
+import { type Knex } from 'knex';
+import type { Options, SortRecord, Sql } 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>;
     preprocessBindings(queryParams: Sql): Sql;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasMultiRelationalSort: boolean): void;
 }

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

@@ -1,3 +1,4 @@
+import {} from 'knex';
 import { SchemaHelper } from '../types.js';
 import { useEnv } from '@directus/env';
 import { preprocessBindings } from '../utils/preprocess-bindings.js';
@@ -31,4 +32,20 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
     }
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
+        if (hasMultiRelationalSort) {
+            /*
+            Cockroach allows aliases to be used in the GROUP BY clause and only needs columns in the GROUP BY clause that
+            are not functionally dependent on the primary key.
+
+            > You can group columns by an alias (i.e., a label assigned to the column with an AS clause) rather than the column name.
+
+            > If aggregate groups are created on a full primary key, any column in the table can be selected as a target_elem,
+              or specified in a HAVING clause.
+
+            https://www.cockroachlabs.com/docs/stable/select-clause#parameters
+             */
+            groupByFields.push(...sortRecords.map(({ alias }) => alias));
+        }
+    }
 }

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

@@ -1,9 +1,10 @@
 import type { Knex } from 'knex';
-import { SchemaHelper, type Sql } from '../types.js';
+import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperMSSQL extends SchemaHelper {
     applyLimit(rootQuery: Knex.QueryBuilder, limit: number): void;
     applyOffset(rootQuery: Knex.QueryBuilder, offset: number): void;
     formatUUID(uuid: string): string;
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasMultiRelationalSort: boolean): void;
 }

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

@@ -30,4 +30,24 @@ export class SchemaHelperMSSQL extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `@p${index}` });
     }
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasMultiRelationalSort) {
+        /*
+        MSSQL requires all selected columns that are not aggregated over are to be present in the GROUP BY clause
+
+        > When the select list has no aggregations, each column in the select list must be included in the GROUP BY list.
+
+        https://learn.microsoft.com/en-us/sql/t-sql/queries/select-group-by-transact-sql?view=sql-server-ver16#g-syntax-variations-for-group-by
+
+        MSSQL does not support aliases in the GROUP BY clause
+
+        > The column expression cannot contain:
+            A column alias that is defined in the SELECT list. It can use a column alias for a derived table that is defined
+            in the FROM clause.
+
+        https://learn.microsoft.com/en-us/sql/t-sql/queries/select-group-by-transact-sql?view=sql-server-ver16
+         */
+        if (sortRecords.length > 0) {
+            groupByFields.push(...sortRecords.map(({ column }) => column));
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 import type { Knex } from 'knex';
-import { SchemaHelper } from '../types.js';
+import { SchemaHelper, type SortRecord } from '../types.js';
 export declare class SchemaHelperMySQL extends SchemaHelper {
     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[], hasMultiRelationalSort: boolean): void;
 }

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

@@ -28,4 +28,37 @@ export class SchemaHelperMySQL extends SchemaHelper {
             return null;
         }
     }
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
+        if (hasMultiRelationalSort) {
+            /*
+            ** MySQL **
+
+            MySQL only requires all selected sort columns that are not functionally dependent on the primary key to be included.
+
+            > If the ONLY_FULL_GROUP_BY SQL mode is enabled (which it is by default),
+              MySQL rejects queries for which the select list, HAVING condition, or ORDER BY list refer to
+              nonaggregated columns that are neither named in the GROUP BY clause nor are functionally dependent on them.
+
+            https://dev.mysql.com/doc/refman/8.4/en/group-by-handling.html
+
+            MySQL allows aliases to be used in the GROUP BY clause
+
+            > You can use the alias in GROUP BY, ORDER BY, or HAVING clauses to refer to the column:
+
+            https://dev.mysql.com/doc/refman/8.4/en/problems-with-alias.html
+
+            ** MariaDB **
+
+            MariaDB does not document how it supports functional dependent columns in GROUP BY clauses.
+            But testing shows that it does support the same features as MySQL in this area.
+
+            MariaDB allows aliases to be used in the GROUP BY clause
+
+            > The GROUP BY expression can be a computed value, and can refer back to an identifer specified with AS.
+
+            https://mariadb.com/kb/en/group-by/#group-by-examples
+             */
+            groupByFields.push(...sortRecords.map(({ alias }) => alias));
+        }
+    }
 }

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

@@ -1,6 +1,7 @@
 import type { KNEX_TYPES } from '@directus/constants';
 import type { Field, Relation, Type } from '@directus/types';
-import type { Options, Sql } from '../types.js';
+import type { Knex } from 'knex';
+import type { Options, SortRecord, Sql } from '../types.js';
 import { SchemaHelper } from '../types.js';
 export declare class SchemaHelperOracle extends SchemaHelper {
     changeToType(table: string, column: string, type: (typeof KNEX_TYPES)[number], options?: Options): Promise<void>;
@@ -9,4 +10,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], _hasMultiRelationalSort: boolean): void;
 }

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

@@ -42,4 +42,25 @@ export class SchemaHelperOracle extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `:${index + 1}` });
     }
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, _hasMultiRelationalSort) {
+        /*
+        Oracle requires all selected columns that are not aggregated over to be present in the GROUP BY clause
+        aliases can not be used before version 23c.
+
+        > If you also specify a group_by_clause in this statement, then this select list can contain only the following
+          types of expressions:
+                * Constants
+                * Aggregate functions and the functions USER, UID, and SYSDATE
+                * Expressions identical to those in the group_by_clause. If the group_by_clause is in a subquery,
+                  then all columns in the select list of the subquery must match the GROUP BY columns in the subquery.
+                  If the select list and GROUP BY columns of a top-level query or of a subquery do not match,
+                  then the statement results in ORA-00979.
+                * Expressions involving the preceding expressions that evaluate to the same value for all rows in a group
+
+        https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/SELECT.html
+         */
+        if (sortRecords.length > 0) {
+            groupByFields.push(...sortRecords.map(({ column }) => column));
+        }
+    }
 }

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

@@ -1,5 +1,7 @@
-import { SchemaHelper, type Sql } from '../types.js';
+import type { Knex } from 'knex';
+import { SchemaHelper, type SortRecord, type Sql } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
+    addInnerSortFieldsToGroupBy(groupByFields: (string | Knex.Raw)[], sortRecords: SortRecord[], hasMultiRelationalSort: boolean): void;
 }

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

@@ -15,4 +15,27 @@ export class SchemaHelperPostgres extends SchemaHelper {
     preprocessBindings(queryParams) {
         return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
     }
+    addInnerSortFieldsToGroupBy(groupByFields, sortRecords, hasMultiRelationalSort) {
+        if (hasMultiRelationalSort) {
+            /*
+            Postgres only requires selected columns that are not functionally dependent on the primary key to be
+            included in the GROUP BY clause. Since the results are already grouped by the primary key, we don't need to
+            always include the sort columns in the GROUP BY but only if there is a multi relational sort involved, eg.
+            a sort column that comes from a related M2O relation.
+
+            > When GROUP BY is present, or any aggregate functions are present, it is not valid for the SELECT list
+              expressions to refer to ungrouped columns except within aggregate functions or when the ungrouped column is
+              functionally dependent on the grouped columns, since there would otherwise be more than one possible value to
+              return for an ungrouped column.
+            https://www.postgresql.org/docs/current/sql-select.html
+
+            Postgres allows aliases to be used in the GROUP BY clause
+
+            > In strict SQL, GROUP BY can only group by columns of the source table but PostgreSQL extends this to also allow
+              GROUP BY to group by columns in the select list.
+      https://www.postgresql.org/docs/16/queries-table-expressions.html#QUERIES-GROUP
+             */
+            groupByFields.push(...sortRecords.map(({ alias }) => alias));
+        }
+    }
 }

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

@@ -3,4 +3,5 @@ export declare class SchemaHelperSQLite extends SchemaHelper {
     preColumnChange(): Promise<boolean>;
     postColumnChange(): Promise<void>;
     getDatabaseSize(): Promise<number | null>;
+    addInnerSortFieldsToGroupBy(): void;
 }

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

@@ -19,4 +19,7 @@ export class SchemaHelperSQLite extends SchemaHelper {
             return null;
         }
     }
+    addInnerSortFieldsToGroupBy() {
+        // SQLite does not need any special handling for inner query sort columns
+    }
 }

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

@@ -12,6 +12,10 @@ export type Sql = {
     sql: string;
     bindings: readonly Knex.Value[];
 };
+export type SortRecord = {
+    alias: string;
+    column: Knex.Raw;
+};
 export declare abstract class SchemaHelper extends DatabaseHelper {
     isOneOfClients(clients: DatabaseClient[]): boolean;
     changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
@@ -32,4 +36,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
      */
     getDatabaseSize(): Promise<number | null>;
     preprocessBindings(queryParams: Sql): Sql;
+    addInnerSortFieldsToGroupBy(_groupByFields: (string | Knex.Raw)[], _sortRecords: SortRecord[], _hasMultiRelationalSort: boolean): void;
 }

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

@@ -97,4 +97,7 @@ export class SchemaHelper extends DatabaseHelper {
     preprocessBindings(queryParams) {
         return queryParams;
     }
+    addInnerSortFieldsToGroupBy(_groupByFields, _sortRecords, _hasMultiRelationalSort) {
+        // no-op by default
+    }
 }

package/dist/database/helpers/schema/utils/preprocess-bindings.d.ts

@@ -1,8 +1,12 @@
+import type { Knex } from 'knex';
 import type { Sql } from '../types.js';
 export type PreprocessBindingsOptions = {
     format(index: number): string;
 };
+/**
+ * Preprocess a SQL query, such that repeated binding values are bound to the same binding index.
+ **/
 export declare function preprocessBindings(queryParams: (Partial<Sql> & Pick<Sql, 'sql'>) | string, options: PreprocessBindingsOptions): {
     sql: string;
-    bindings: import("knex").Knex.Value[];
+    bindings: Knex.Value[];
 };