@directus/api 22.1.1 → 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/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[];
 };

package/dist/database/helpers/schema/utils/preprocess-bindings.js

@@ -1,30 +1,36 @@
 import { isString } from 'lodash-es';
+/**
+ * Preprocess a SQL query, such that repeated binding values are bound to the same binding index.
+ **/
 export function preprocessBindings(queryParams, options) {
     const query = { bindings: [], ...(isString(queryParams) ? { sql: queryParams } : queryParams) };
-    const bindingIndices = new Array(query.bindings.length);
-    for (let i = 0; i < query.bindings.length; i++) {
-        const binding = query.bindings[i];
-        const prevIndex = query.bindings.findIndex((b, j) => j < i && b === binding);
-        if (prevIndex !== -1) {
-            bindingIndices[i] = prevIndex;
-        }
-        else {
-            bindingIndices[i] = i;
-        }
-    }
+    // bindingIndices[i] is the index of the first occurrence of query.bindings[i]
+    const bindingIndices = new Map();
+    // The new, deduplicated bindings
+    const bindings = [];
     let matchIndex = 0;
-    let currentBindingIndex = 0;
-    const sql = query.sql.replace(/(\\*)(\?)/g, function (_, escapes) {
+    let nextBindingIndex = 0;
+    const sql = query.sql.replace(/(\\*)(\?)/g, (_, escapes) => {
         if (escapes.length % 2) {
             // Return an escaped question mark, so it stays escaped
             return `${'\\'.repeat(escapes.length)}?`;
         }
+        const binding = query.bindings[matchIndex];
+        let bindingIndex;
+        if (bindingIndices.has(binding)) {
+            // This index belongs to a binding that has been encountered before.
+            bindingIndex = bindingIndices.get(binding);
+        }
         else {
-            const bindingIndex = bindingIndices[matchIndex] === matchIndex ? currentBindingIndex++ : bindingIndices[matchIndex];
-            matchIndex++;
-            return options.format(bindingIndex);
+            // The first time the value is encountered, set the index lookup to the current index
+            // Use the nextBindingIndex to get the next unused binding index that is used in the new, deduplicated bindings
+            bindingIndex = nextBindingIndex++;
+            bindingIndices.set(binding, bindingIndex);
+            bindings.push(binding);
         }
+        // Increment the loop counter
+        matchIndex++;
+        return options.format(bindingIndex);
     });
-    const bindings = query.bindings.filter((_, i) => bindingIndices[i] === i);
     return { ...query, sql, bindings };
 }

package/dist/database/migrations/20240817A-update-icon-fields-length.d.ts

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

package/dist/database/migrations/20240817A-update-icon-fields-length.js

@@ -0,0 +1,55 @@
+import { getHelpers } from '../helpers/index.js';
+export async function up(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_collections', 'icon', 'string', {
+        length: 64,
+    });
+    await helper.changeToType('directus_dashboards', 'icon', 'string', {
+        nullable: false,
+        default: 'dashboard',
+        length: 64,
+    });
+    await helper.changeToType('directus_flows', 'icon', 'string', {
+        length: 64,
+    });
+    await helper.changeToType('directus_panels', 'icon', 'string', {
+        default: null,
+        length: 64,
+    });
+    await helper.changeToType('directus_presets', 'icon', 'string', {
+        default: 'bookmark',
+        length: 64,
+    });
+    await helper.changeToType('directus_roles', 'icon', 'string', {
+        nullable: false,
+        default: 'supervised_user_circle',
+        length: 64,
+    });
+}
+export async function down(knex) {
+    const helper = getHelpers(knex).schema;
+    await helper.changeToType('directus_collections', 'icon', 'string', {
+        length: 30,
+    });
+    await helper.changeToType('directus_dashboards', 'icon', 'string', {
+        nullable: false,
+        default: 'dashboard',
+        length: 30,
+    });
+    await helper.changeToType('directus_flows', 'icon', 'string', {
+        length: 30,
+    });
+    await helper.changeToType('directus_panels', 'icon', 'string', {
+        default: null,
+        length: 30,
+    });
+    await helper.changeToType('directus_presets', 'icon', 'string', {
+        default: 'bookmark',
+        length: 30,
+    });
+    await helper.changeToType('directus_roles', 'icon', 'string', {
+        nullable: false,
+        default: 'supervised_user_circle',
+        length: 30,
+    });
+}

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

@@ -86,19 +86,21 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
                     orderByString += ', ';
                 }
                 const sortAlias = `sort_${generateAlias()}`;
+                let orderByColumn;
                 if (sortRecord.column.includes('.')) {
                     const [alias, field] = sortRecord.column.split('.');
                     const originalCollectionName = getCollectionFromAlias(alias, aliasMap);
                     dbQuery.select(getColumn(knex, alias, field, sortAlias, schema, { originalCollectionName }));
                     orderByString += `?? ${sortRecord.order}`;
-                    orderByFields.push(getColumn(knex, alias, field, false, schema, { originalCollectionName }));
+                    orderByColumn = getColumn(knex, alias, field, false, schema, { originalCollectionName });
                 }
                 else {
                     dbQuery.select(getColumn(knex, table, sortRecord.column, sortAlias, schema));
                     orderByString += `?? ${sortRecord.order}`;
-                    orderByFields.push(getColumn(knex, table, sortRecord.column, false, schema));
+                    orderByColumn = getColumn(knex, table, sortRecord.column, false, schema);
                 }
-                innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order });
+                orderByFields.push(orderByColumn);
+                innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order, column: orderByColumn });
             });
             if (hasMultiRelationalSort) {
                 dbQuery = helpers.schema.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
@@ -171,11 +173,15 @@ export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cas
         // based on the case/when of that field.
         dbQuery.select(o2mNodes.map(innerPreprocess).filter((x) => x !== null));
         const groupByFields = [knex.raw('??.??', [table, primaryKey])];
-        if (hasMultiRelationalSort) {
-            // Sort fields that are not directly in the table the primary key is from need to be included in the group
-            // by clause, otherwise this causes problems on some DBs
-            groupByFields.push(...innerQuerySortRecords.map(({ alias }) => knex.raw('??', alias)));
-        }
+        // For some DB vendors sort fields need to be included in the group by clause, otherwise this causes problems those DBs
+        // since sort fields are selected in the inner query, and they expect all selected columns to be in
+        // the group by clause or aggregated over.
+        // For some DBs the field needs to be the actual raw column expression, since aliases are not available in the
+        // group by clause.
+        // Since the fields are expected to be the same for a single primary key it is safe to include them in the
+        // group by without influencing the result.
+        // This inclusion depends on the DB vendor, as such it is handled in a dialect specific helper.
+        helpers.schema.addInnerSortFieldsToGroupBy(groupByFields, innerQuerySortRecords, hasMultiRelationalSort ?? false);
         dbQuery.groupBy(groupByFields);
     }
     const wrapperQuery = knex

package/dist/extensions/manager.js

@@ -156,7 +156,7 @@ export class ExtensionManager {
             }
         }
         if (this.options.watch && !wasWatcherInitialized) {
-            this.updateWatchedExtensions(Array.from(this.localExtensions.values()));
+            this.updateWatchedExtensions([...this.extensions]);
         }
         this.messenger.subscribe(this.reloadChannel, (payload) => {
             // Ignore requests for reloading that were published by the current process
@@ -327,7 +327,7 @@ export class ExtensionManager {
         const extensionDir = path.resolve(getExtensionsPath());
         const registryDir = path.join(extensionDir, '.registry');
         const toPackageExtensionPaths = (extensions) => extensions
-            .filter((extension) => extension.local && extension.path.startsWith(extensionDir) && !extension.path.startsWith(registryDir))
+            .filter((extension) => extension.local && !extension.path.startsWith(registryDir))
             .flatMap((extension) => isTypeIn(extension, HYBRID_EXTENSION_TYPES) || extension.type === 'bundle'
             ? [
                 path.resolve(extension.path, extension.entrypoint.app),

package/dist/logger/index.d.ts

@@ -1,9 +1,15 @@
 /// <reference types="qs" />
 import type { RequestHandler } from 'express';
 import { type Logger } from 'pino';
+import { LogsStream } from './logs-stream.js';
 export declare const _cache: {
     logger: Logger<never> | undefined;
+    logsStream: LogsStream | undefined;
+    httpLogsStream: LogsStream | undefined;
 };
 export declare const useLogger: () => Logger<never>;
+export declare const getLogsStream: (pretty: boolean) => LogsStream;
+export declare const getHttpLogsStream: (pretty: boolean) => LogsStream;
+export declare const getLoggerLevelValue: (level: string) => number;
 export declare const createLogger: () => Logger<never>;
 export declare const createExpressLogger: () => RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;