@directus/api 22.1.1 → 23.0.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/auth/drivers/ldap.js

@@ -172,7 +172,7 @@ export class LDAPAuthDriver extends AuthDriver {
         }
         const logger = useLogger();
         await this.validateBindClient();
-        const { userDn, userScope, userAttribute, groupDn, groupScope, groupAttribute, defaultRoleId } = this.config;
+        const { userDn, userScope, userAttribute, groupDn, groupScope, groupAttribute, defaultRoleId, syncUserInfo } = this.config;
         const userInfo = await this.fetchUserInfo(userDn, new ldap.EqualityFilter({
             attribute: userAttribute ?? 'cn',
             value: payload['identifier'],
@@ -201,11 +201,22 @@ export class LDAPAuthDriver extends AuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            let updatedUserPayload = await emitter.emitFilter(`auth.update`, {}, { identifier: userInfo.dn, provider: this.config['provider'], providerPayload: { userInfo, userRole } }, { database: getDatabase(), schema: this.schema, accountability: null });
+            let emitPayload = {};
             // Only sync roles if the AD groups are configured
             if (groupDn) {
-                updatedUserPayload = { role: userRole?.id ?? defaultRoleId ?? null, ...updatedUserPayload };
+                emitPayload = {
+                    role: userRole?.id ?? defaultRoleId ?? null,
+                };
             }
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userInfo.firstName,
+                    last_name: userInfo.lastName,
+                    email: userInfo.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, { identifier: userInfo.dn, provider: this.config['provider'], providerPayload: { userInfo, userRole } }, { database: getDatabase(), schema: this.schema, accountability: null });
             // Update user to update properties that might have changed
             await this.usersService.updateOne(userId, updatedUserPayload);
             return userId;

package/dist/auth/drivers/oauth2.js

@@ -106,7 +106,7 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         }
         // Flatten response to support dot indexes
         userInfo = flatten(userInfo);
-        const { provider, emailKey, identifierKey, allowPublicRegistration } = this.config;
+        const { provider, emailKey, identifierKey, allowPublicRegistration, syncUserInfo } = this.config;
         const email = userInfo[emailKey ?? 'email'] ? String(userInfo[emailKey ?? 'email']) : undefined;
         // Fallback to email if explicit identifier not found
         const identifier = userInfo[identifierKey] ? String(userInfo[identifierKey]) : email;
@@ -127,7 +127,18 @@ export class OAuth2AuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
+            let emitPayload = {
+                auth_data: userPayload.auth_data,
+            };
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userPayload.first_name,
+                    last_name: userPayload.last_name,
+                    email: userPayload.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },

package/dist/auth/drivers/openid.js

@@ -125,7 +125,7 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         }
         // Flatten response to support dot indexes
         userInfo = flatten(userInfo);
-        const { provider, identifierKey, allowPublicRegistration, requireVerifiedEmail } = this.config;
+        const { provider, identifierKey, allowPublicRegistration, requireVerifiedEmail, syncUserInfo } = this.config;
         const email = userInfo['email'] ? String(userInfo['email']) : undefined;
         // Fallback to email if explicit identifier not found
         const identifier = userInfo[identifierKey ?? 'sub'] ? String(userInfo[identifierKey ?? 'sub']) : email;
@@ -146,7 +146,18 @@ export class OpenIDAuthDriver extends LocalAuthDriver {
         if (userId) {
             // Run hook so the end user has the chance to augment the
             // user that is about to be updated
-            const updatedUserPayload = await emitter.emitFilter(`auth.update`, { auth_data: userPayload.auth_data }, {
+            let emitPayload = {
+                auth_data: userPayload.auth_data,
+            };
+            if (syncUserInfo) {
+                emitPayload = {
+                    ...emitPayload,
+                    first_name: userPayload.first_name,
+                    last_name: userPayload.last_name,
+                    email: userPayload.email,
+                };
+            }
+            const updatedUserPayload = await emitter.emitFilter(`auth.update`, emitPayload, {
                 identifier,
                 provider: this.config['provider'],
                 providerPayload: { accessToken: tokenSet.access_token, userInfo },

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

@@ -1,13 +1,13 @@
 import { useEnv } from '@directus/env';
-import Keyv from 'keyv';
+import Keyv, {} from 'keyv';
 import { useBus } from './bus/index.js';
 import { useLogger } from './logger/index.js';
+import { clearCache as clearPermissionCache } from './permissions/cache.js';
 import { redisConfigAvailable } from './redis/index.js';
 import { compress, decompress } from './utils/compress.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { getMilliseconds } from './utils/get-milliseconds.js';
 import { validateEnv } from './utils/validate-env.js';
-import { clearCache as clearPermissionCache } from './permissions/cache.js';
 import { createRequire } from 'node:module';
 const logger = useLogger();
 const env = useEnv();
@@ -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');
 }
@@ -106,10 +106,10 @@ function getKeyvInstance(store, ttl, namespaceSuffix) {
 function getConfig(store = 'memory', ttl, namespaceSuffix = '') {
     const config = {
         namespace: `${env['CACHE_NAMESPACE']}${namespaceSuffix}`,
-        ttl,
+        ...(ttl && { ttl }),
     };
     if (store === 'redis') {
-        const KeyvRedis = require('@keyv/redis');
+        const { default: KeyvRedis } = require('@keyv/redis');
         config.store = new KeyvRedis(env['REDIS'] || getConfigFromEnv('REDIS'), { useRedisSets: false });
     }
     return config;

package/dist/cli/commands/init/questions.d.ts

@@ -4,18 +4,18 @@ export declare const databaseQuestions: {
         filepath: string;
     }) => Record<string, string>)[];
     mysql2: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     pg: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     cockroachdb: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     oracledb: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
     mssql: (({ client }: {
-        client: Exclude<Driver, 'sqlite3'>;
+        client: Exclude<Driver, "sqlite3">;
     }) => Record<string, any>)[];
 };

package/dist/cli/commands/schema/apply.d.ts

@@ -1,4 +1,5 @@
 export declare function apply(snapshotPath: string, options?: {
     yes: boolean;
     dryRun: boolean;
+    ignoreRules: string;
 }): Promise<void>;

package/dist/cli/commands/schema/apply.js

@@ -11,6 +11,22 @@ import { isNestedMetaUpdate } from '../../../utils/apply-diff.js';
 import { applySnapshot } from '../../../utils/apply-snapshot.js';
 import { getSnapshotDiff } from '../../../utils/get-snapshot-diff.js';
 import { getSnapshot } from '../../../utils/get-snapshot.js';
+function filterSnapshotDiff(snapshot, filters) {
+    const filterSet = new Set(filters);
+    function shouldKeep(item) {
+        if (filterSet.has(item.collection))
+            return false;
+        if (item.field && filterSet.has(`${item.collection}.${item.field}`))
+            return false;
+        return true;
+    }
+    const filteredDiff = {
+        collections: snapshot.collections.filter((item) => shouldKeep(item)),
+        fields: snapshot.fields.filter((item) => shouldKeep(item)),
+        relations: snapshot.relations.filter((item) => shouldKeep(item)),
+    };
+    return filteredDiff;
+}
 export async function apply(snapshotPath, options) {
     const logger = useLogger();
     const filename = path.resolve(process.cwd(), snapshotPath);
@@ -31,7 +47,10 @@ export async function apply(snapshotPath, options) {
             snapshot = parseJSON(fileContents);
         }
         const currentSnapshot = await getSnapshot({ database });
-        const snapshotDiff = getSnapshotDiff(currentSnapshot, snapshot);
+        let snapshotDiff = getSnapshotDiff(currentSnapshot, snapshot);
+        if (options?.ignoreRules) {
+            snapshotDiff = filterSnapshotDiff(snapshotDiff, options.ignoreRules.split(','));
+        }
         if (snapshotDiff.collections.length === 0 &&
             snapshotDiff.fields.length === 0 &&
             snapshotDiff.relations.length === 0) {

package/dist/cli/index.js

@@ -81,6 +81,7 @@ export async function createCli() {
         .description('Apply a snapshot file to the current database')
         .option('-y, --yes', `Assume "yes" as answer to all prompts and run non-interactively`)
         .option('-d, --dry-run', 'Plan and log changes to be applied', false)
+        .option('--ignoreRules <value>', `Comma-separated list of collections and or fields to ignore. Format: "products.title,reviews" this will ignore applying changes to the title field in the products collection and the entire reviews collection`)
         .argument('<path>', 'Path to snapshot file')
         .action(apply);
     await emitter.emitInit('cli.after', { program });

package/dist/cli/utils/create-env/env-stub.liquid

@@ -313,7 +313,7 @@ EXTENSIONS_AUTO_RELOAD=false
 EMAIL_FROM="no-reply@example.com"
 
 # What to use to send emails. One of
-# sendmail, smtp, mailgun, sendgrid, ses.
+# sendmail, smtp, mailgun, ses.
 EMAIL_TRANSPORT="sendmail"
 EMAIL_SENDMAIL_NEW_LINE="unix"
 EMAIL_SENDMAIL_PATH="/usr/sbin/sendmail"
@@ -340,6 +340,3 @@ EMAIL_SENDMAIL_PATH="/usr/sbin/sendmail"
 ## Email (Mailgun Transport)
 # EMAIL_MAILGUN_API_KEY="key-1234123412341234"
 # EMAIL_MAILGUN_DOMAIN="a domain name from https://app.mailgun.com/app/sending/domains"
-
-## Email (SendGrid Transport)
-# EMAIL_SENDGRID_API_KEY="key-1234123412341234"

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/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
+    }
 }