@directus/api 26.0.1 → 27.0.1

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.d.ts

@@ -0,0 +1,8 @@
+import type { FieldOverview } from '@directus/types';
+export declare function getFilterType(fields: Record<string, FieldOverview>, key: string, collection?: string): {
+    type: "string" | "boolean" | "json" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    special?: never;
+} | {
+    type: "string" | "boolean" | "json" | "binary" | "time" | "text" | "integer" | "float" | "alias" | "uuid" | "dateTime" | "timestamp" | "bigInteger" | "date" | "decimal" | "hash" | "csv" | "geometry" | "geometry.Point" | "geometry.LineString" | "geometry.Polygon" | "geometry.MultiPoint" | "geometry.MultiLineString" | "geometry.MultiPolygon" | "unknown";
+    special: string[];
+};

package/dist/database/run-ast/lib/apply-query/filter/get-filter-type.js

@@ -0,0 +1,20 @@
+import { parseFilterKey } from '../../../../../utils/parse-filter-key.js';
+import { InvalidQueryError } from '@directus/errors';
+import { getFunctionsForType, getOutputTypeForFunction } from '@directus/utils';
+export function getFilterType(fields, key, collection = 'unknown') {
+    const { fieldName, functionName } = parseFilterKey(key);
+    const field = fields[fieldName];
+    if (!field) {
+        throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
+    }
+    const { type } = field;
+    if (functionName) {
+        const availableFunctions = getFunctionsForType(type);
+        if (!availableFunctions.includes(functionName)) {
+            throw new InvalidQueryError({ reason: `Invalid filter key "${key}" on "${collection}"` });
+        }
+        const functionType = getOutputTypeForFunction(functionName);
+        return { type: functionType };
+    }
+    return { type, special: field.special };
+}

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

@@ -0,0 +1,8 @@
+import type { Filter, Permission, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../../../utils/get-column-path.js';
+export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, aliasMap: AliasMap, cases: Filter[], permissions: Permission[]): {
+    query: Knex.QueryBuilder<any, any>;
+    hasJoins: boolean;
+    hasMultiRelationalFilter: boolean;
+};

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

@@ -0,0 +1,151 @@
+import { InvalidQueryError } from '@directus/errors';
+import { getCases } from '../../../../../permissions/modules/process-ast/lib/get-cases.js';
+import { getColumnPath } from '../../../../../utils/get-column-path.js';
+import { getRelationInfo } from '../../../../../utils/get-relation-info.js';
+import { getHelpers } from '../../../../helpers/index.js';
+import { addJoin } from '../add-join.js';
+import { getFilterPath } from '../get-filter-path.js';
+import { getOperation } from '../get-operation.js';
+import applyQuery from '../index.js';
+import { getFilterType } from './get-filter-type.js';
+import { applyOperator } from './operator.js';
+import { validateOperator } from './validate-operator.js';
+export function applyFilter(knex, schema, rootQuery, rootFilter, collection, aliasMap, cases, permissions) {
+    const relations = schema.relations;
+    let hasJoins = false;
+    let hasMultiRelationalFilter = false;
+    addJoins(rootQuery, rootFilter, collection);
+    addWhereClauses(knex, rootQuery, rootFilter, collection);
+    return { query: rootQuery, hasJoins, hasMultiRelationalFilter };
+    function addJoins(dbQuery, filter, collection) {
+        // eslint-disable-next-line prefer-const
+        for (let [key, value] of Object.entries(filter)) {
+            if (key === '_or' || key === '_and') {
+                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
+                // permission checks, as {} already matches full permissions.
+                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
+                    // But only do so, if the value is not equal to `cases` (since then this is not permission related at all)
+                    // or the length of value is 1, ie. only the empty filter.
+                    // If the length is more than one it means that some items (and fields) might now be available, so
+                    // the joins are required for the case/when construction.
+                    if (value !== cases || value.length === 1) {
+                        continue;
+                    }
+                    else {
+                        // Otherwise we can at least filter out all empty filters that would not add joins anyway
+                        value = value.filter((subFilter) => Object.keys(subFilter).length > 0);
+                    }
+                }
+                value.forEach((subFilter) => {
+                    addJoins(dbQuery, subFilter, collection);
+                });
+                continue;
+            }
+            const filterPath = getFilterPath(key, value);
+            if (filterPath.length > 1 ||
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
+                const { hasMultiRelational, isJoinAdded } = addJoin({
+                    path: filterPath,
+                    collection,
+                    knex,
+                    schema,
+                    rootQuery,
+                    aliasMap,
+                });
+                if (!hasJoins) {
+                    hasJoins = isJoinAdded;
+                }
+                if (!hasMultiRelationalFilter) {
+                    hasMultiRelationalFilter = hasMultiRelational;
+                }
+            }
+        }
+    }
+    function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === '_or' || key === '_and') {
+                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
+                // permission checks, as {} already matches full permissions.
+                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
+                    continue;
+                }
+                /** @NOTE this callback function isn't called until Knex runs the query */
+                dbQuery[logical].where((subQuery) => {
+                    value.forEach((subFilter) => {
+                        addWhereClauses(knex, subQuery, subFilter, collection, key === '_and' ? 'and' : 'or');
+                    });
+                });
+                continue;
+            }
+            const filterPath = getFilterPath(key, value);
+            /**
+             * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+             */
+            const pathRoot = filterPath[0].split(':')[0];
+            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
+            const operation = getOperation(key, value);
+            if (!operation)
+                continue;
+            const { operator: filterOperator, value: filterValue } = operation;
+            if (filterPath.length > 1 ||
+                (!(key.includes('(') && key.includes(')')) && schema.collections[collection]?.fields[key]?.type === 'alias')) {
+                if (!relation)
+                    continue;
+                if (relationType === 'o2m' || relationType === 'o2a') {
+                    let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
+                    if (relationType === 'o2a') {
+                        pkField = knex.raw(getHelpers(knex).schema.castA2oPrimaryKey(), [pkField]);
+                    }
+                    const childKey = Object.keys(value)?.[0];
+                    if (childKey === '_none' || childKey === '_some') {
+                        const subQueryBuilder = (filter, cases) => (subQueryKnex) => {
+                            const field = relation.field;
+                            const collection = relation.collection;
+                            const column = `${collection}.${field}`;
+                            subQueryKnex
+                                .select({ [field]: column })
+                                .from(collection)
+                                .whereNotNull(column);
+                            applyQuery(knex, relation.collection, subQueryKnex, { filter }, schema, cases, permissions);
+                        };
+                        const { cases: subCases } = getCases(relation.collection, permissions, []);
+                        if (childKey === '_none') {
+                            dbQuery[logical].whereNotIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
+                            continue;
+                        }
+                        else if (childKey === '_some') {
+                            dbQuery[logical].whereIn(pkField, subQueryBuilder(Object.values(value)[0], subCases));
+                            continue;
+                        }
+                    }
+                }
+                if (filterPath.includes('_none') || filterPath.includes('_some')) {
+                    throw new InvalidQueryError({
+                        reason: `"${filterPath.includes('_none') ? '_none' : '_some'}" can only be used with top level relational alias field`,
+                    });
+                }
+                const { columnPath, targetCollection, addNestedPkField } = getColumnPath({
+                    path: filterPath,
+                    collection,
+                    relations,
+                    aliasMap,
+                    schema,
+                });
+                if (addNestedPkField) {
+                    filterPath.push(addNestedPkField);
+                }
+                if (!columnPath)
+                    continue;
+                const { type, special } = getFilterType(schema.collections[targetCollection].fields, filterPath.at(-1), targetCollection);
+                validateOperator(type, filterOperator, special);
+                applyOperator(knex, dbQuery, schema, columnPath, filterOperator, filterValue, logical, targetCollection);
+            }
+            else {
+                const { type, special } = getFilterType(schema.collections[collection].fields, filterPath[0], collection);
+                validateOperator(type, filterOperator, special);
+                const aliasedCollection = aliasMap['']?.alias || collection;
+                applyOperator(knex, dbQuery, schema, `${aliasedCollection}.${filterPath[0]}`, filterOperator, filterValue, logical, collection);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function applyOperator(knex: Knex, dbQuery: Knex.QueryBuilder, schema: SchemaOverview, key: string, operator: string, compareValue: any, logical?: 'and' | 'or', originalCollectionName?: string): void;

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

@@ -0,0 +1,175 @@
+import { getColumn } from '../../../utils/get-column.js';
+import { getOutputTypeForFunction } from '@directus/utils';
+import { getHelpers } from '../../../../helpers/index.js';
+export function applyOperator(knex, dbQuery, schema, key, operator, compareValue, logical = 'and', originalCollectionName) {
+    const helpers = getHelpers(knex);
+    const [table, column] = key.split('.');
+    // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
+    const selectionRaw = getColumn(knex, table, column, false, schema, { originalCollectionName });
+    // Knex supports "raw" in the columnName parameter, but isn't typed as such. Too bad..
+    // See https://github.com/knex/knex/issues/4518 @TODO remove as any once knex is updated
+    // These operators don't rely on a value, and can thus be used without one (eg `?filter[field][_null]`)
+    if ((operator === '_null' && compareValue !== false) ||
+        (operator === '_nnull' && compareValue === false) ||
+        (operator === '_eq' && compareValue === null)) {
+        dbQuery[logical].whereNull(selectionRaw);
+        return;
+    }
+    if ((operator === '_nnull' && compareValue !== false) ||
+        (operator === '_null' && compareValue === false) ||
+        (operator === '_neq' && compareValue === null)) {
+        dbQuery[logical].whereNotNull(selectionRaw);
+        return;
+    }
+    if ((operator === '_empty' && compareValue !== false) || (operator === '_nempty' && compareValue === false)) {
+        dbQuery[logical].andWhere((query) => {
+            query.whereNull(key).orWhere(key, '=', '');
+        });
+    }
+    if ((operator === '_nempty' && compareValue !== false) || (operator === '_empty' && compareValue === false)) {
+        dbQuery[logical].andWhere((query) => {
+            query.whereNotNull(key).andWhere(key, '!=', '');
+        });
+    }
+    // The following fields however, require a value to be run. If no value is passed, we
+    // ignore them. This allows easier use in GraphQL, where you wouldn't be able to
+    // conditionally build out your filter structure (#4471)
+    if (compareValue === undefined)
+        return;
+    if (Array.isArray(compareValue)) {
+        // Tip: when using a `[Type]` type in GraphQL, but don't provide the variable, it'll be
+        // reported as [undefined].
+        // We need to remove any undefined values, as they are useless
+        compareValue = compareValue.filter((val) => val !== undefined);
+    }
+    // Cast filter value (compareValue) based on function used
+    if (column.includes('(') && column.includes(')')) {
+        const functionName = column.split('(')[0];
+        const type = getOutputTypeForFunction(functionName);
+        if (['integer', 'float', 'decimal'].includes(type)) {
+            compareValue = Array.isArray(compareValue) ? compareValue.map(Number) : Number(compareValue);
+        }
+    }
+    // Cast filter value (compareValue) based on type of field being filtered against
+    const [collection, field] = key.split('.');
+    const mappedCollection = (originalCollectionName || collection);
+    if (mappedCollection in schema.collections && field in schema.collections[mappedCollection].fields) {
+        const type = schema.collections[mappedCollection].fields[field].type;
+        if (['date', 'dateTime', 'time', 'timestamp'].includes(type)) {
+            if (Array.isArray(compareValue)) {
+                compareValue = compareValue.map((val) => helpers.date.parse(val));
+            }
+            else {
+                compareValue = helpers.date.parse(compareValue);
+            }
+        }
+        if (['integer', 'float', 'decimal'].includes(type)) {
+            if (Array.isArray(compareValue)) {
+                compareValue = compareValue.map((val) => Number(val));
+            }
+            else {
+                compareValue = Number(compareValue);
+            }
+        }
+    }
+    if (operator === '_eq') {
+        dbQuery[logical].where(selectionRaw, '=', compareValue);
+    }
+    if (operator === '_neq') {
+        dbQuery[logical].whereNot(selectionRaw, compareValue);
+    }
+    if (operator === '_ieq') {
+        dbQuery[logical].whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+    }
+    if (operator === '_nieq') {
+        dbQuery[logical].whereRaw(`LOWER(??) <> ?`, [selectionRaw, `${compareValue.toLowerCase()}`]);
+    }
+    if (operator === '_contains') {
+        dbQuery[logical].where(selectionRaw, 'like', `%${compareValue}%`);
+    }
+    if (operator === '_ncontains') {
+        dbQuery[logical].whereNot(selectionRaw, 'like', `%${compareValue}%`);
+    }
+    if (operator === '_icontains') {
+        dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+    }
+    if (operator === '_nicontains') {
+        dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}%`]);
+    }
+    if (operator === '_starts_with') {
+        dbQuery[logical].where(key, 'like', `${compareValue}%`);
+    }
+    if (operator === '_nstarts_with') {
+        dbQuery[logical].whereNot(key, 'like', `${compareValue}%`);
+    }
+    if (operator === '_istarts_with') {
+        dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+    }
+    if (operator === '_nistarts_with') {
+        dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `${compareValue.toLowerCase()}%`]);
+    }
+    if (operator === '_ends_with') {
+        dbQuery[logical].where(key, 'like', `%${compareValue}`);
+    }
+    if (operator === '_nends_with') {
+        dbQuery[logical].whereNot(key, 'like', `%${compareValue}`);
+    }
+    if (operator === '_iends_with') {
+        dbQuery[logical].whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+    }
+    if (operator === '_niends_with') {
+        dbQuery[logical].whereRaw(`LOWER(??) NOT LIKE ?`, [selectionRaw, `%${compareValue.toLowerCase()}`]);
+    }
+    if (operator === '_gt') {
+        dbQuery[logical].where(selectionRaw, '>', compareValue);
+    }
+    if (operator === '_gte') {
+        dbQuery[logical].where(selectionRaw, '>=', compareValue);
+    }
+    if (operator === '_lt') {
+        dbQuery[logical].where(selectionRaw, '<', compareValue);
+    }
+    if (operator === '_lte') {
+        dbQuery[logical].where(selectionRaw, '<=', compareValue);
+    }
+    if (operator === '_in') {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        dbQuery[logical].whereIn(selectionRaw, value);
+    }
+    if (operator === '_nin') {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        dbQuery[logical].whereNotIn(selectionRaw, value);
+    }
+    if (operator === '_between') {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (value.length !== 2)
+            return;
+        dbQuery[logical].whereBetween(selectionRaw, value);
+    }
+    if (operator === '_nbetween') {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (value.length !== 2)
+            return;
+        dbQuery[logical].whereNotBetween(selectionRaw, value);
+    }
+    if (operator == '_intersects') {
+        dbQuery[logical].whereRaw(helpers.st.intersects(key, compareValue));
+    }
+    if (operator == '_nintersects') {
+        dbQuery[logical].whereRaw(helpers.st.nintersects(key, compareValue));
+    }
+    if (operator == '_intersects_bbox') {
+        dbQuery[logical].whereRaw(helpers.st.intersects_bbox(key, compareValue));
+    }
+    if (operator == '_nintersects_bbox') {
+        dbQuery[logical].whereRaw(helpers.st.nintersects_bbox(key, compareValue));
+    }
+}

package/dist/database/run-ast/lib/apply-query/filter/validate-operator.d.ts

@@ -0,0 +1,2 @@
+import type { Type } from '@directus/types';
+export declare function validateOperator(type: Type, filterOperator: string, special?: string[]): void;

package/dist/database/run-ast/lib/apply-query/filter/validate-operator.js

@@ -0,0 +1,18 @@
+import { InvalidQueryError } from '@directus/errors';
+import { getFilterOperatorsForType } from '@directus/utils';
+export function validateOperator(type, filterOperator, special) {
+    if (filterOperator.startsWith('_')) {
+        filterOperator = filterOperator.slice(1);
+    }
+    if (!getFilterOperatorsForType(type).includes(filterOperator)) {
+        throw new InvalidQueryError({
+            reason: `"${type}" field type does not contain the "_${filterOperator}" filter operator`,
+        });
+    }
+    if (special?.includes('conceal') &&
+        !getFilterOperatorsForType('hash').includes(filterOperator)) {
+        throw new InvalidQueryError({
+            reason: `Field with "conceal" special does not allow the "_${filterOperator}" filter operator`,
+        });
+    }
+}

package/dist/database/run-ast/lib/apply-query/get-filter-path.d.ts

@@ -0,0 +1 @@
+export declare function getFilterPath(key: string, value: Record<string, any>): string[];

package/dist/database/run-ast/lib/apply-query/get-filter-path.js

@@ -0,0 +1,13 @@
+import { isObject } from '@directus/utils';
+export function getFilterPath(key, value) {
+    const path = [key];
+    const childKey = Object.keys(value)[0];
+    if (!childKey || (childKey.startsWith('_') === true && !['_none', '_some'].includes(childKey))) {
+        return path;
+    }
+    const nestedValue = Object.values(value)[0];
+    if (isObject(value)) {
+        path.push(...getFilterPath(childKey, nestedValue));
+    }
+    return path;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Returns null or the operation information form a FieldFilter
+ */
+export declare function getOperation(key: string, value: unknown): {
+    operator: string;
+    value: unknown;
+} | null;

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

@@ -0,0 +1,19 @@
+import { isObject } from '@directus/utils';
+/**
+ * Returns null or the operation information form a FieldFilter
+ */
+export function getOperation(key, value) {
+    if (key === '_and' || key === '_or')
+        return null;
+    if (key.startsWith('_') && key !== '_none' && key !== '_some') {
+        return { operator: key, value };
+    }
+    else if (!isObject(value)) {
+        return { operator: '_eq', value };
+    }
+    const childKey = Object.keys(value)[0];
+    if (childKey) {
+        return getOperation(childKey, Object.values(value)[0]);
+    }
+    return null;
+}

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

@@ -0,0 +1,20 @@
+import type { Filter, Permission, Query, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../../utils/get-column-path.js';
+export declare const generateAlias: (size?: number) => string;
+type ApplyQueryOptions = {
+    aliasMap?: AliasMap;
+    isInnerQuery?: boolean;
+    hasMultiRelationalSort?: boolean | undefined;
+    groupWhenCases?: number[][] | undefined;
+    groupColumnPositions?: number[] | undefined;
+};
+/**
+ * Apply the Query to a given Knex query builder instance
+ */
+export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, cases: Filter[], permissions: Permission[], options?: ApplyQueryOptions): {
+    query: Knex.QueryBuilder<any, any>;
+    hasJoins: boolean;
+    hasMultiRelationalFilter: boolean;
+};
+export {};

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

@@ -0,0 +1,92 @@
+import { customAlphabet } from 'nanoid/non-secure';
+import { getHelpers } from '../../../helpers/index.js';
+import { applyCaseWhen } from '../../utils/apply-case-when.js';
+import { getColumn } from '../../utils/get-column.js';
+import { applyLimit, applyOffset } from './pagination.js';
+import { joinFilterWithCases } from './join-filter-with-cases.js';
+import { applySort } from './sort.js';
+import { applyFilter } from './filter/index.js';
+import { applySearch } from './search.js';
+import { applyAggregate } from './aggregate.js';
+export const generateAlias = customAlphabet('abcdefghijklmnopqrstuvwxyz', 5);
+/**
+ * Apply the Query to a given Knex query builder instance
+ */
+export default function applyQuery(knex, collection, dbQuery, query, schema, cases, permissions, options) {
+    const aliasMap = options?.aliasMap ?? Object.create(null);
+    let hasJoins = false;
+    let hasMultiRelationalFilter = false;
+    applyLimit(knex, dbQuery, query.limit);
+    if (query.offset) {
+        applyOffset(knex, dbQuery, query.offset);
+    }
+    if (query.page && query.limit && query.limit !== -1) {
+        applyOffset(knex, dbQuery, query.limit * (query.page - 1));
+    }
+    if (query.sort && !options?.isInnerQuery && !options?.hasMultiRelationalSort) {
+        const sortResult = applySort(knex, schema, dbQuery, query.sort, query.aggregate, collection, aliasMap);
+        if (!hasJoins) {
+            hasJoins = sortResult.hasJoins;
+        }
+    }
+    // `cases` are the permissions cases that are required for the current data set. We're
+    // dynamically adding those into the filters that the user provided to enforce the permission
+    // rules. You should be able to read an item if one or more of the cases matches. The actual case
+    // is reused in the column selection case/when to dynamically return or nullify the field values
+    // you're actually allowed to read
+    const filter = joinFilterWithCases(query.filter, cases);
+    if (filter) {
+        const filterResult = applyFilter(knex, schema, dbQuery, filter, collection, aliasMap, cases, permissions);
+        if (!hasJoins) {
+            hasJoins = filterResult.hasJoins;
+        }
+        hasMultiRelationalFilter = filterResult.hasMultiRelationalFilter;
+    }
+    if (query.group) {
+        const helpers = getHelpers(knex);
+        const rawColumns = query.group.map((column) => getColumn(knex, collection, column, false, schema));
+        let columns;
+        if (options?.groupWhenCases) {
+            if (helpers.capabilities.supportsColumnPositionInGroupBy() && options.groupColumnPositions) {
+                // This can be streamlined for databases that support reusing the alias in group by expressions
+                columns = query.group.map((column, index) => options.groupColumnPositions[index] !== undefined ? knex.raw(options.groupColumnPositions[index]) : column);
+            }
+            else {
+                // Reconstruct the columns with the case/when logic
+                columns = rawColumns.map((column, index) => applyCaseWhen({
+                    columnCases: options.groupWhenCases[index].map((caseIndex) => cases[caseIndex]),
+                    column,
+                    aliasMap,
+                    cases,
+                    table: collection,
+                    permissions,
+                }, {
+                    knex,
+                    schema,
+                }));
+            }
+            if (query.sort && query.sort.length === 1 && query.sort[0] === query.group[0]) {
+                // Special case, where the sort query is injected by the group by operation
+                dbQuery.clear('order');
+                let order = 'asc';
+                if (query.sort[0].startsWith('-')) {
+                    order = 'desc';
+                }
+                // @ts-expect-error (orderBy does not accept Knex.Raw for some reason, even though it is handled correctly)
+                // https://github.com/knex/knex/issues/5711
+                dbQuery.orderBy([{ column: columns[0], order }]);
+            }
+        }
+        else {
+            columns = rawColumns;
+        }
+        dbQuery.groupBy(columns);
+    }
+    if (query.search) {
+        applySearch(knex, schema, dbQuery, query.search, collection, aliasMap, permissions);
+    }
+    if (query.aggregate) {
+        applyAggregate(schema, dbQuery, query.aggregate, collection, hasJoins);
+    }
+    return { query: dbQuery, hasJoins, hasMultiRelationalFilter };
+}

package/dist/database/run-ast/lib/apply-query/join-filter-with-cases.d.ts

@@ -0,0 +1,2 @@
+import type { Filter } from '@directus/types';
+export declare function joinFilterWithCases(filter: Filter | null | undefined, cases: Filter[]): Filter | null;

package/dist/database/run-ast/lib/apply-query/join-filter-with-cases.js

@@ -0,0 +1,12 @@
+export function joinFilterWithCases(filter, cases) {
+    if (cases.length > 0 && !filter) {
+        return { _or: cases };
+    }
+    else if (filter && cases.length === 0) {
+        return filter ?? null;
+    }
+    else if (filter && cases.length > 0) {
+        return { _and: [filter, { _or: cases }] };
+    }
+    return null;
+}

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

@@ -0,0 +1,3 @@
+import { MockClient } from 'knex-mock-client';
+export declare class Client_SQLite3 extends MockClient {
+}

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

@@ -0,0 +1,4 @@
+import { MockClient } from 'knex-mock-client';
+// in order for the helpers to know the client type
+export class Client_SQLite3 extends MockClient {
+}

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

@@ -0,0 +1,3 @@
+import type { Knex } from 'knex';
+export declare function applyLimit(knex: Knex, rootQuery: Knex.QueryBuilder, limit: any): void;
+export declare function applyOffset(knex: Knex, rootQuery: Knex.QueryBuilder, offset: any): void;

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

@@ -0,0 +1,11 @@
+import { getHelpers } from '../../../helpers/index.js';
+export function applyLimit(knex, rootQuery, limit) {
+    if (typeof limit === 'number') {
+        getHelpers(knex).schema.applyLimit(rootQuery, limit);
+    }
+}
+export function applyOffset(knex, rootQuery, offset) {
+    if (typeof offset === 'number') {
+        getHelpers(knex).schema.applyOffset(rootQuery, offset);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { Permission, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../../utils/get-column-path.js';
+export declare function applySearch(knex: Knex, schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string, aliasMap: AliasMap, permissions: Permission[]): void;