@directus/api 21.0.0 → 22.1.0

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

@@ -0,0 +1,200 @@
+import { REGEX_BETWEEN_PARENS } from '@directus/constants';
+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 { getDeepQuery } from '../utils/get-deep-query.js';
+import { getRelatedCollection } from '../utils/get-related-collection.js';
+import { getRelation } from '../utils/get-relation.js';
+import { convertWildcards } from './convert-wildcards.js';
+export async function parseFields(options, context) {
+    let { fields } = options;
+    if (!fields)
+        return [];
+    fields = await convertWildcards({
+        fields,
+        parentCollection: options.parentCollection,
+        query: options.query,
+        accountability: options.accountability,
+    }, context);
+    if (!fields || !Array.isArray(fields))
+        return [];
+    const children = [];
+    const policies = options.accountability && options.accountability.admin === false
+        ? await fetchPolicies(options.accountability, context)
+        : null;
+    const relationalStructure = Object.create(null);
+    for (const fieldKey of fields) {
+        let name = fieldKey;
+        if (options.query.alias) {
+            // check for field alias (is one of the key)
+            if (name in options.query.alias) {
+                name = options.query.alias[fieldKey];
+            }
+        }
+        const isRelational = name.includes('.') ||
+            // We'll always treat top level o2m fields as a related item. This is an alias field, otherwise it won't return
+            // anything
+            !!context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === name);
+        if (isRelational) {
+            // field is relational
+            const parts = fieldKey.split('.');
+            let rootField = parts[0];
+            let collectionScope = null;
+            // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
+            if (rootField.includes(':')) {
+                const [key, scope] = rootField.split(':');
+                rootField = key;
+                collectionScope = scope;
+            }
+            if (rootField in relationalStructure === false) {
+                if (collectionScope) {
+                    relationalStructure[rootField] = { [collectionScope]: [] };
+                }
+                else {
+                    relationalStructure[rootField] = [];
+                }
+            }
+            if (parts.length > 1) {
+                const childKey = parts.slice(1).join('.');
+                if (collectionScope) {
+                    if (collectionScope in relationalStructure[rootField] === false) {
+                        relationalStructure[rootField][collectionScope] = [];
+                    }
+                    relationalStructure[rootField][collectionScope].push(childKey);
+                }
+                else {
+                    relationalStructure[rootField].push(childKey);
+                }
+            }
+        }
+        else {
+            if (name.includes('(') && name.includes(')')) {
+                const columnName = name.match(REGEX_BETWEEN_PARENS)[1];
+                const foundField = context.schema.collections[options.parentCollection].fields[columnName];
+                if (foundField && foundField.type === 'alias') {
+                    const foundRelation = context.schema.relations.find((relation) => relation.related_collection === options.parentCollection && relation.meta?.one_field === columnName);
+                    if (foundRelation) {
+                        children.push({
+                            type: 'functionField',
+                            name,
+                            fieldKey,
+                            query: {},
+                            relatedCollection: foundRelation.collection,
+                            whenCase: [],
+                            cases: [],
+                        });
+                        continue;
+                    }
+                }
+            }
+            if (name.includes(':')) {
+                const [key, scope] = name.split(':');
+                if (key in relationalStructure === false) {
+                    relationalStructure[key] = { [scope]: [] };
+                }
+                else if (scope in relationalStructure[key] === false) {
+                    relationalStructure[key][scope] = [];
+                }
+                continue;
+            }
+            children.push({ type: 'field', name, fieldKey, whenCase: [] });
+        }
+    }
+    for (const [fieldKey, nestedFields] of Object.entries(relationalStructure)) {
+        let fieldName = fieldKey;
+        if (options.query.alias && fieldKey in options.query.alias) {
+            fieldName = options.query.alias[fieldKey];
+        }
+        const relatedCollection = getRelatedCollection(context.schema, options.parentCollection, fieldName);
+        const relation = getRelation(context.schema, options.parentCollection, fieldName);
+        if (!relation)
+            continue;
+        const relationType = getRelationType({
+            relation,
+            collection: options.parentCollection,
+            field: fieldName,
+        });
+        if (!relationType)
+            continue;
+        let child = null;
+        if (relationType === 'a2o') {
+            const allowedCollections = relation.meta.one_allowed_collections;
+            child = {
+                type: 'a2o',
+                names: allowedCollections,
+                children: {},
+                query: {},
+                relatedKey: {},
+                parentKey: context.schema.collections[options.parentCollection].primary,
+                fieldKey: fieldKey,
+                relation: relation,
+                cases: {},
+                whenCase: [],
+            };
+            for (const relatedCollection of allowedCollections) {
+                child.children[relatedCollection] = await parseFields({
+                    parentCollection: relatedCollection,
+                    fields: Array.isArray(nestedFields)
+                        ? nestedFields
+                        : nestedFields[relatedCollection] || [],
+                    query: options.query,
+                    deep: options.deep?.[`${fieldKey}:${relatedCollection}`],
+                    accountability: options.accountability,
+                }, context);
+                child.query[relatedCollection] = getDeepQuery(options.deep?.[`${fieldKey}:${relatedCollection}`] || {});
+                child.relatedKey[relatedCollection] = context.schema.collections[relatedCollection].primary;
+            }
+        }
+        else if (relatedCollection) {
+            if (options.accountability && options.accountability.admin === false && policies) {
+                const permissions = await fetchPermissions({
+                    action: 'read',
+                    collections: [relatedCollection],
+                    policies: policies,
+                    accountability: options.accountability,
+                }, context);
+                // Skip related collection if no permissions
+                if (permissions.length === 0) {
+                    continue;
+                }
+            }
+            // update query alias for children parseFields
+            const deepAlias = getDeepQuery(options.deep?.[fieldKey] || {})?.['alias'];
+            if (!isEmpty(deepAlias))
+                options.query.alias = deepAlias;
+            child = {
+                type: relationType,
+                name: relatedCollection,
+                fieldKey: fieldKey,
+                parentKey: context.schema.collections[options.parentCollection].primary,
+                relatedKey: context.schema.collections[relatedCollection].primary,
+                relation: relation,
+                query: getDeepQuery(options.deep?.[fieldKey] || {}),
+                children: await parseFields({
+                    parentCollection: relatedCollection,
+                    fields: nestedFields,
+                    query: options.query,
+                    deep: options.deep?.[fieldKey] || {},
+                    accountability: options.accountability,
+                }, context),
+                cases: [],
+                whenCase: [],
+            };
+            if (relationType === 'o2m' && !child.query.sort) {
+                child.query.sort = [relation.meta?.sort_field || context.schema.collections[relation.collection].primary];
+            }
+        }
+        if (child) {
+            children.push(child);
+        }
+    }
+    // Deduplicate any children fields that are included both as a regular field, and as a nested m2o field
+    const nestedCollectionNodes = children.filter((childNode) => childNode.type !== 'field');
+    return children.filter((childNode) => {
+        const existsAsNestedRelational = !!nestedCollectionNodes.find((nestedCollectionNode) => childNode.fieldKey === nestedCollectionNode.fieldKey);
+        if (childNode.type === 'field' && existsAsNestedRelational)
+            return false;
+        return true;
+    });
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Convert Deep query object to regular query object by ignoring all nested fields and returning the
+ * `_` prefixed fields as top level query fields
+ *
+ * @example
+ *
+ * ```js
+ * getDeepQuery({
+ *   _sort: ['a']
+ * });
+ * // => { sort: ['a'] }
+ * ```
+ */
+export declare function getDeepQuery(query: Record<string, any>): Record<string, any>;

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

@@ -0,0 +1,17 @@
+import { mapKeys, omitBy } from 'lodash-es';
+/**
+ * Convert Deep query object to regular query object by ignoring all nested fields and returning the
+ * `_` prefixed fields as top level query fields
+ *
+ * @example
+ *
+ * ```js
+ * getDeepQuery({
+ *   _sort: ['a']
+ * });
+ * // => { sort: ['a'] }
+ * ```
+ */
+export function getDeepQuery(query) {
+    return mapKeys(omitBy(query, (_value, key) => key.startsWith('_') === false), (_value, key) => key.substring(1));
+}

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

@@ -0,0 +1,2 @@
+import type { SchemaOverview } from '@directus/types';
+export declare function getRelatedCollection(schema: SchemaOverview, collection: string, field: string): string | null;

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

@@ -0,0 +1,13 @@
+import { getRelation } from './get-relation.js';
+export function getRelatedCollection(schema, collection, field) {
+    const relation = getRelation(schema, collection, field);
+    if (!relation)
+        return null;
+    if (relation.collection === collection && relation.field === field) {
+        return relation.related_collection || null;
+    }
+    if (relation.related_collection === collection && relation.meta?.one_field === field) {
+        return relation.collection || null;
+    }
+    return null;
+}

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

@@ -0,0 +1,2 @@
+import type { SchemaOverview } from '@directus/types';
+export declare function getRelation(schema: SchemaOverview, collection: string, field: string): import("@directus/types").Relation | undefined;

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

@@ -0,0 +1,7 @@
+export function getRelation(schema, collection, field) {
+    const relation = schema.relations.find((relation) => {
+        return ((relation.collection === collection && relation.field === field) ||
+            (relation.related_collection === collection && relation.meta?.one_field === field));
+    });
+    return relation;
+}

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

@@ -1,9 +1,10 @@
-import type { Query, SchemaOverview } from '@directus/types';
+import type { Filter, 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;
 };
 export declare abstract class FnHelper extends DatabaseHelper {

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

@@ -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).query;
+            countQuery = applyFilter(this.knex, this.schema, countQuery, options.query.filter, relation.collection, aliasMap, options.cases ?? []).query;
         }
         return this.knex.raw('(' + countQuery.toQuery() + ')');
     }

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

@@ -6,7 +6,7 @@ export declare class GeometryHelperMSSQL extends GeometryHelper {
     isTrue(expression: Knex.Raw): Knex.Raw<any>;
     isFalse(expression: Knex.Raw): Knex.Raw<any>;
     createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
-    asText(table: string, column: string): Knex.Raw;
+    asText(table: string, column: string, alias: string | false): Knex.Raw;
     fromText(text: string): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;
     _intersects_bbox(key: string, geojson: GeoJSONGeometry): Knex.Raw;

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

@@ -12,8 +12,10 @@ export class GeometryHelperMSSQL extends GeometryHelper {
         }
         return table.specificType(field.field, 'geometry');
     }
-    asText(table, column) {
-        return this.knex.raw('??.??.STAsText() as ??', [table, column, column]);
+    asText(table, column, alias) {
+        if (alias)
+            return this.knex.raw('??.??.STAsText() as ??', [table, column, alias]);
+        return this.knex.raw('??.??.STAsText()', [table, column]);
     }
     fromText(text) {
         return this.knex.raw('geometry::STGeomFromText(?, 4326)', text);

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

@@ -1,7 +1,7 @@
 import { GeometryHelper } from '../types.js';
 export class GeometryHelperMySQL extends GeometryHelper {
     collect(table, column) {
-        return this.knex.raw(`concat('geometrycollection(', group_concat(? separator ', '), ')'`, this.asText(table, column));
+        return this.knex.raw(`concat('geometrycollection(', group_concat(? separator ', '), ')'`, this.asText(table, column, column));
     }
     fromText(text) {
         return this.knex.raw('st_geomfromtext(?)', text);

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

@@ -6,7 +6,7 @@ export declare class GeometryHelperOracle extends GeometryHelper {
     isTrue(expression: Knex.Raw): Knex.Raw<any>;
     isFalse(expression: Knex.Raw): Knex.Raw<any>;
     createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
-    asText(table: string, column: string): Knex.Raw;
+    asText(table: string, column: string, alias: string | false): Knex.Raw;
     asGeoJSON(table: string, column: string): Knex.Raw;
     fromText(text: string): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;

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

@@ -12,8 +12,10 @@ export class GeometryHelperOracle extends GeometryHelper {
         }
         return table.specificType(field.field, 'sdo_geometry');
     }
-    asText(table, column) {
-        return this.knex.raw('sdo_util.to_wktgeometry(??.??) as ??', [table, column, column]);
+    asText(table, column, alias) {
+        if (alias)
+            return this.knex.raw('sdo_util.to_wktgeometry(??.??) as ??', [table, column, alias]);
+        return this.knex.raw('sdo_util.to_wktgeometry(??.??)', [table, column]);
     }
     asGeoJSON(table, column) {
         return this.knex.raw('sdo_util.to_geojson(??.??) as ??', [table, column, column]);
@@ -30,6 +32,6 @@ export class GeometryHelperOracle extends GeometryHelper {
         return this.knex.raw(`sdo_overlapbdyintersect(sdo_geom.sdo_mbr(??), sdo_geom.sdo_mbr(?))`, [key, geometry]);
     }
     collect(table, column) {
-        return this.knex.raw(`concat('geometrycollection(', listagg(?, ', '), ')'`, this.asText(table, column));
+        return this.knex.raw(`concat('geometrycollection(', listagg(?, ', '), ')'`, this.asText(table, column, column));
     }
 }

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

@@ -7,7 +7,7 @@ export declare abstract class GeometryHelper extends DatabaseHelper {
     isTrue(expression: Knex.Raw): Knex.Raw<any>;
     isFalse(expression: Knex.Raw): Knex.Raw<any>;
     createColumn(table: Knex.CreateTableBuilder, field: RawField | Field): Knex.ColumnBuilder;
-    asText(table: string, column: string): Knex.Raw;
+    asText(table: string, column: string, alias: string | false): Knex.Raw;
     fromText(text: string): Knex.Raw;
     fromGeoJSON(geojson: GeoJSONGeometry): Knex.Raw;
     _intersects(key: string, geojson: GeoJSONGeometry): Knex.Raw;

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

@@ -14,8 +14,10 @@ export class GeometryHelper extends DatabaseHelper {
         const type = field.type.split('.')[1] ?? 'geometry';
         return table.specificType(field.field, type);
     }
-    asText(table, column) {
-        return this.knex.raw('st_astext(??.??) as ??', [table, column, column]);
+    asText(table, column, alias) {
+        if (alias)
+            return this.knex.raw('st_astext(??.??) as ??', [table, column, alias]);
+        return this.knex.raw('st_astext(??.??)', [table, column]);
     }
     fromText(text) {
         return this.knex.raw('st_geomfromtext(?, 4326)', text);

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

@@ -8,10 +8,10 @@ import * as sequenceHelpers from './sequence/index.js';
 import * as numberHelpers from './number/index.js';
 export declare function getHelpers(database: Knex): {
     date: dateHelpers.postgres | dateHelpers.oracle | dateHelpers.mysql | dateHelpers.mssql | dateHelpers.sqlite;
-    st: geometryHelpers.mysql | geometryHelpers.postgres | geometryHelpers.mssql | geometryHelpers.sqlite | geometryHelpers.oracle | geometryHelpers.redshift;
-    schema: schemaHelpers.mysql | schemaHelpers.cockroachdb | schemaHelpers.mssql | schemaHelpers.postgres | schemaHelpers.sqlite | schemaHelpers.oracle | schemaHelpers.redshift;
+    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;
 };
-export declare function getFunctions(database: Knex, schema: SchemaOverview): fnHelpers.mysql | fnHelpers.postgres | fnHelpers.mssql | fnHelpers.sqlite | fnHelpers.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/schema/dialects/cockroachdb.d.ts

@@ -1,8 +1,9 @@
 import type { KNEX_TYPES } from '@directus/constants';
-import type { Options } from '../types.js';
+import type { Options, 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;
 }

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

@@ -1,5 +1,6 @@
 import { SchemaHelper } from '../types.js';
 import { useEnv } from '@directus/env';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 const env = useEnv();
 export class SchemaHelperCockroachDb extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
@@ -27,4 +28,7 @@ export class SchemaHelperCockroachDb extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    }
 }

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

@@ -1,8 +1,9 @@
 import type { Knex } from 'knex';
-import { SchemaHelper } from '../types.js';
+import { SchemaHelper, 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;
 }

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

@@ -1,4 +1,5 @@
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 export class SchemaHelperMSSQL extends SchemaHelper {
     applyLimit(rootQuery, limit) {
         // The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries,
@@ -26,4 +27,7 @@ export class SchemaHelperMSSQL extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `@p${index}` });
+    }
 }

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

@@ -1,6 +1,6 @@
 import type { KNEX_TYPES } from '@directus/constants';
 import type { Field, Relation, Type } from '@directus/types';
-import type { Options } from '../types.js';
+import type { Options, 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>;
@@ -8,4 +8,5 @@ export declare class SchemaHelperOracle extends SchemaHelper {
     preRelationChange(relation: Partial<Relation>): void;
     processFieldType(field: Field): Type;
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

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

@@ -1,4 +1,5 @@
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 export class SchemaHelperOracle extends SchemaHelper {
     async changeToType(table, column, type, options = {}) {
         await this.changeToTypeByCopy(table, column, type, options);
@@ -38,4 +39,7 @@ export class SchemaHelperOracle extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `:${index + 1}` });
+    }
 }

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

@@ -1,4 +1,5 @@
-import { SchemaHelper } from '../types.js';
+import { SchemaHelper, type Sql } from '../types.js';
 export declare class SchemaHelperPostgres extends SchemaHelper {
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

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

@@ -1,5 +1,6 @@
 import { useEnv } from '@directus/env';
 import { SchemaHelper } from '../types.js';
+import { preprocessBindings } from '../utils/preprocess-bindings.js';
 const env = useEnv();
 export class SchemaHelperPostgres extends SchemaHelper {
     async getDatabaseSize() {
@@ -11,4 +12,7 @@ export class SchemaHelperPostgres extends SchemaHelper {
             return null;
         }
     }
+    preprocessBindings(queryParams) {
+        return preprocessBindings(queryParams, { format: (index) => `$${index + 1}` });
+    }
 }

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

@@ -8,6 +8,10 @@ export type Options = {
     default?: any;
     length?: number;
 };
+export type Sql = {
+    sql: string;
+    bindings: readonly Knex.Value[];
+};
 export declare abstract class SchemaHelper extends DatabaseHelper {
     isOneOfClients(clients: DatabaseClient[]): boolean;
     changeNullable(table: string, column: string, nullable: boolean): Promise<void>;
@@ -27,4 +31,5 @@ export declare abstract class SchemaHelper extends DatabaseHelper {
      * @returns Size of the database in bytes
      */
     getDatabaseSize(): Promise<number | null>;
+    preprocessBindings(queryParams: Sql): Sql;
 }

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

@@ -94,4 +94,7 @@ export class SchemaHelper extends DatabaseHelper {
     async getDatabaseSize() {
         return null;
     }
+    preprocessBindings(queryParams) {
+        return queryParams;
+    }
 }

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

@@ -0,0 +1,8 @@
+import type { Sql } from '../types.js';
+export type PreprocessBindingsOptions = {
+    format(index: number): string;
+};
+export declare function preprocessBindings(queryParams: (Partial<Sql> & Pick<Sql, 'sql'>) | string, options: PreprocessBindingsOptions): {
+    sql: string;
+    bindings: import("knex").Knex.Value[];
+};

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

@@ -0,0 +1,30 @@
+import { isString } from 'lodash-es';
+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;
+        }
+    }
+    let matchIndex = 0;
+    let currentBindingIndex = 0;
+    const sql = query.sql.replace(/(\\*)(\?)/g, function (_, escapes) {
+        if (escapes.length % 2) {
+            // Return an escaped question mark, so it stays escaped
+            return `${'\\'.repeat(escapes.length)}?`;
+        }
+        else {
+            const bindingIndex = bindingIndices[matchIndex] === matchIndex ? currentBindingIndex++ : bindingIndices[matchIndex];
+            matchIndex++;
+            return options.format(bindingIndex);
+        }
+    });
+    const bindings = query.bindings.filter((_, i) => bindingIndices[i] === i);
+    return { ...query, sql, bindings };
+}

package/dist/database/index.js

@@ -1,5 +1,6 @@
 import { useEnv } from '@directus/env';
 import { createInspector } from '@directus/schema';
+import { isObject } from '@directus/utils';
 import fse from 'fs-extra';
 import knex from 'knex';
 import { merge } from 'lodash-es';
@@ -106,6 +107,10 @@ export function getDatabase() {
         };
     }
     if (client === 'mysql') {
+        // Remove the conflicting `filename` option, defined by default in the Docker Image
+        if (isObject(knexConfig.connection))
+            delete knexConfig.connection['filename'];
+        Object.assign(knexConfig, { client: 'mysql2' });
         poolConfig.afterCreate = async (conn, callback) => {
             logger.trace('Retrieving database version');
             const run = promisify(conn.query.bind(conn));
@@ -189,7 +194,7 @@ export async function validateDatabaseConnection(database) {
 export function getDatabaseClient(database) {
     database = database ?? getDatabase();
     switch (database.client.constructor.name) {
-        case 'Client_MySQL':
+        case 'Client_MySQL2':
             return 'mysql';
         case 'Client_PG':
             return 'postgres';

package/dist/database/migrations/20210519A-add-system-fk-triggers.js

@@ -1,5 +1,6 @@
 import { createInspector } from '@directus/schema';
 import { useLogger } from '../../logger/index.js';
+import { getDatabaseClient } from '../index.js';
 /**
  * Things to keep in mind:
  *
@@ -99,7 +100,7 @@ export async function up(knex) {
              * MySQL won't delete the index when you drop the foreign key constraint. Gotta make
              * sure to clean those up as well
              */
-            if (knex.client.constructor.name === 'Client_MySQL') {
+            if (getDatabaseClient(knex) === 'mysql') {
                 try {
                     await knex.schema.alterTable(update.table, (table) => {
                         // Knex uses a default convention for index names: `table_column_type`
@@ -140,7 +141,7 @@ export async function down(knex) {
              * MySQL won't delete the index when you drop the foreign key constraint. Gotta make
              * sure to clean those up as well
              */
-            if (knex.client.constructor.name === 'Client_MySQL') {
+            if (getDatabaseClient(knex) === 'mysql') {
                 try {
                     await knex.schema.alterTable(update.table, (table) => {
                         // Knex uses a default convention for index names: `table_column_type`

package/dist/database/migrations/20230721A-require-shares-fields.js

@@ -1,9 +1,8 @@
 import { createInspector } from '@directus/schema';
 import { useLogger } from '../../logger/index.js';
-import { getHelpers } from '../helpers/index.js';
+import { getDatabaseClient } from '../index.js';
 export async function up(knex) {
-    const helper = getHelpers(knex).schema;
-    const isMysql = helper.isOneOfClients(['mysql']);
+    const isMysql = getDatabaseClient(knex) === 'mysql';
     if (isMysql) {
         await dropConstraint(knex);
     }
@@ -16,8 +15,7 @@ export async function up(knex) {
     }
 }
 export async function down(knex) {
-    const helper = getHelpers(knex).schema;
-    const isMysql = helper.isOneOfClients(['mysql']);
+    const isMysql = getDatabaseClient(knex) === 'mysql';
     if (isMysql) {
         await dropConstraint(knex);
     }