@directus/api 19.3.0 → 20.0.0-rc.0

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

@@ -0,0 +1,194 @@
+import { useEnv } from '@directus/env';
+import { cloneDeep } from 'lodash-es';
+import applyQuery, { applyLimit, applySort, generateAlias } from '../../../utils/apply-query.js';
+import { getCollectionFromAlias } from '../../../utils/get-collection-from-alias.js';
+import { getColumn } from '../../../utils/get-column.js';
+import { getHelpers } from '../../helpers/index.js';
+import { applyCaseWhen } from '../utils/apply-case-when.js';
+import { getColumnPreprocessor } from '../utils/get-column-pre-processor.js';
+import { getNodeAlias } from '../utils/get-field-alias.js';
+import { getInnerQueryColumnPreProcessor } from '../utils/get-inner-query-column-pre-processor.js';
+export function getDBQuery(schema, knex, table, fieldNodes, o2mNodes, query, cases) {
+    const aliasMap = Object.create(null);
+    const env = useEnv();
+    const preProcess = getColumnPreprocessor(knex, schema, table, cases, aliasMap);
+    const queryCopy = cloneDeep(query);
+    const helpers = getHelpers(knex);
+    const hasCaseWhen = o2mNodes.some((node) => node.whenCase && node.whenCase.length > 0) ||
+        fieldNodes.some((node) => node.whenCase && node.whenCase.length > 0);
+    queryCopy.limit = typeof queryCopy.limit === 'number' ? queryCopy.limit : Number(env['QUERY_LIMIT_DEFAULT']);
+    // Queries with aggregates and groupBy will not have duplicate result
+    if (queryCopy.aggregate || queryCopy.group) {
+        const flatQuery = knex.from(table).select(fieldNodes.map((node) => preProcess(node)));
+        return applyQuery(knex, table, flatQuery, queryCopy, schema, cases).query;
+    }
+    const primaryKey = schema.collections[table].primary;
+    let dbQuery = knex.from(table);
+    let sortRecords;
+    const innerQuerySortRecords = [];
+    let hasMultiRelationalSort;
+    if (queryCopy.sort) {
+        const sortResult = applySort(knex, schema, dbQuery, queryCopy, table, aliasMap, true);
+        if (sortResult) {
+            sortRecords = sortResult.sortRecords;
+            hasMultiRelationalSort = sortResult.hasMultiRelationalSort;
+        }
+    }
+    const { hasMultiRelationalFilter } = applyQuery(knex, table, dbQuery, queryCopy, schema, cases, {
+        aliasMap,
+        isInnerQuery: true,
+        hasMultiRelationalSort,
+    });
+    const needsInnerQuery = hasMultiRelationalSort || hasMultiRelationalFilter;
+    if (needsInnerQuery) {
+        dbQuery.select(`${table}.${primaryKey}`);
+        // Only add distinct if there are no case/when constructs, since otherwise we rely on group by
+        if (!hasCaseWhen)
+            dbQuery.distinct();
+    }
+    else {
+        dbQuery.select(fieldNodes.map((node) => preProcess(node)));
+        // Add flags for o2m fields with case/when to the let the DB to the partial item permissions
+        dbQuery.select(o2mNodes
+            .filter((node) => node.whenCase && node.whenCase.length > 0)
+            .map((node) => {
+            const columnCases = node.whenCase.map((index) => cases[index]);
+            return applyCaseWhen({
+                column: knex.raw(1),
+                columnCases,
+                aliasMap,
+                cases,
+                table,
+                alias: node.fieldKey,
+            }, { knex, schema });
+        }));
+    }
+    if (sortRecords) {
+        // Clears the order if any, eg: from MSSQL offset
+        dbQuery.clear('order');
+        if (needsInnerQuery) {
+            let orderByString = '';
+            const orderByFields = [];
+            sortRecords.map((sortRecord) => {
+                if (orderByString.length !== 0) {
+                    orderByString += ', ';
+                }
+                const sortAlias = `sort_${generateAlias()}`;
+                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 }));
+                }
+                else {
+                    dbQuery.select(getColumn(knex, table, sortRecord.column, sortAlias, schema));
+                    orderByString += `?? ${sortRecord.order}`;
+                    orderByFields.push(getColumn(knex, table, sortRecord.column, false, schema));
+                }
+                innerQuerySortRecords.push({ alias: sortAlias, order: sortRecord.order });
+            });
+            dbQuery.orderByRaw(orderByString, orderByFields);
+            if (hasMultiRelationalSort) {
+                dbQuery = helpers.schema.applyMultiRelationalSort(knex, dbQuery, table, primaryKey, orderByString, orderByFields);
+            }
+        }
+        else {
+            sortRecords.map((sortRecord) => {
+                if (sortRecord.column.includes('.')) {
+                    const [alias, field] = sortRecord.column.split('.');
+                    sortRecord.column = getColumn(knex, alias, field, false, schema, {
+                        originalCollectionName: getCollectionFromAlias(alias, aliasMap),
+                    });
+                }
+                else {
+                    sortRecord.column = getColumn(knex, table, sortRecord.column, false, schema);
+                }
+            });
+            dbQuery.orderBy(sortRecords);
+        }
+    }
+    if (!needsInnerQuery)
+        return dbQuery;
+    const innerCaseWhenAliasPrefix = generateAlias();
+    if (hasCaseWhen) {
+        /* If there are cases, we need to employ a trick in order to evaluate the case/when structure in the inner query,
+           while passing the result of the evaluation to the outer query. The case/when needs to be evaluated in the inner
+           query since only there all joined in tables, that might be required for the case/when, are available.
+
+           The problem is, that the resulting columns can not be directly selected in the inner query,
+           as a `SELECT DISTINCT` does not work for all datatypes in all vendors.
+
+           So instead of having an inner query which might look like this:
+
+           SELECT DISTINCT ...,
+             CASE WHEN <condition> THEN <actual-column> END AS <alias>
+
+             Another problem is that all not all rows with the same primary key are guaranteed to have the same value for
+             the columns with the case/when, so we to `or` those together, but counting the number of flags in a group by
+             operation. This way the flag is set to > 0 if any of the rows in the group allows access to the column.
+
+           The inner query only evaluates the condition and passes up or-ed flag, that is used in the wrapper query to select
+           the actual column:
+
+           SELECT ...,
+             COUNT (CASE WHEN <condition> THEN 1 END) AS <random-prefix>_<alias>
+             ...
+             GROUP BY <primary-key>
+
+            Then, in the wrapper query there is no need to evaluate the condition again, but instead rely on the flag:
+
+            SELECT ...,
+              CASE WHEN `inner`.<random-prefix>_<alias> > 0 THEN <actual-column> END AS <alias>
+         */
+        const innerPreprocess = getInnerQueryColumnPreProcessor(knex, schema, table, cases, aliasMap, innerCaseWhenAliasPrefix);
+        // To optimize the query we avoid having unnecessary columns in the inner query, that don't have a caseWhen, since
+        // they are selected in the outer query directly
+        dbQuery.select(fieldNodes.map(innerPreprocess).filter((x) => x !== null));
+        // In addition to the regular columns select a flag that indicates if a user has access to o2m related field
+        // based on the case/when of that field.
+        dbQuery.select(o2mNodes.map(innerPreprocess).filter((x) => x !== null));
+        dbQuery.groupByRaw(`${table}.${primaryKey}`);
+    }
+    const wrapperQuery = knex
+        .from(table)
+        .innerJoin(knex.raw('??', dbQuery.as('inner')), `${table}.${primaryKey}`, `inner.${primaryKey}`);
+    if (!hasCaseWhen) {
+        // No need for case/when in the wrapper query, just select the preprocessed columns
+        wrapperQuery.select(fieldNodes.map((node) => preProcess(node)));
+    }
+    else {
+        // This applies a simplified case/when construct in the wrapper query, that only looks at flag > 1
+        // Distinguish between column with and without case/when and handle them differently
+        const plainColumns = fieldNodes.filter((fieldNode) => !fieldNode.whenCase || fieldNode.whenCase.length === 0);
+        const whenCaseColumns = fieldNodes.filter((fieldNode) => fieldNode.whenCase && fieldNode.whenCase.length > 0);
+        // Select the plain columns
+        wrapperQuery.select(plainColumns.map((node) => preProcess(node)));
+        // Select the case/when columns based on the flag from the inner query
+        wrapperQuery.select(whenCaseColumns.map((fieldNode) => {
+            const alias = getNodeAlias(fieldNode);
+            const innerAlias = `${innerCaseWhenAliasPrefix}_${alias}`;
+            // Preprocess the column without the case/when, since that is applied in a simpler fashion in the select
+            const column = preProcess({ ...fieldNode, whenCase: [] }, { noAlias: true });
+            return knex.raw(`CASE WHEN ??.?? > 0 THEN ?? END as ??`, ['inner', innerAlias, column, alias]);
+        }));
+        // Pass the flags of o2m fields up through the wrapper query
+        wrapperQuery.select(o2mNodes
+            .filter((node) => node.whenCase && node.whenCase.length > 0)
+            .map((node) => {
+            const alias = node.fieldKey;
+            const innerAlias = `${innerCaseWhenAliasPrefix}_${alias}`;
+            return knex.raw(`CASE WHEN ??.?? > 0 THEN 1 END as ??`, ['inner', innerAlias, alias]);
+        }));
+    }
+    if (sortRecords && needsInnerQuery) {
+        innerQuerySortRecords.map((innerQuerySortRecord) => {
+            wrapperQuery.orderBy(`inner.${innerQuerySortRecord.alias}`, innerQuerySortRecord.order);
+        });
+        if (hasMultiRelationalSort) {
+            wrapperQuery.where('inner.directus_row_number', '=', 1);
+            applyLimit(knex, wrapperQuery, queryCopy.limit);
+        }
+    }
+    return wrapperQuery;
+}

package/dist/database/run-ast/lib/parse-current-level.d.ts

@@ -0,0 +1,7 @@
+import type { Query, SchemaOverview } from '@directus/types';
+import type { FieldNode, FunctionFieldNode, NestedCollectionNode } from '../../../types/ast.js';
+export declare function parseCurrentLevel(schema: SchemaOverview, collection: string, children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[], query: Query): Promise<{
+    fieldNodes: FieldNode[];
+    nestedCollectionNodes: NestedCollectionNode[];
+    primaryKeyField: string;
+}>;

package/dist/database/run-ast/lib/parse-current-level.js

@@ -0,0 +1,41 @@
+import { parseFilterKey } from '../../../utils/parse-filter-key.js';
+export async function parseCurrentLevel(schema, collection, children, query) {
+    const primaryKeyField = schema.collections[collection].primary;
+    const columnsInCollection = Object.keys(schema.collections[collection].fields);
+    const columnsToSelectInternal = [];
+    const nestedCollectionNodes = [];
+    for (const child of children) {
+        if (child.type === 'field' || child.type === 'functionField') {
+            const { fieldName } = parseFilterKey(child.name);
+            if (columnsInCollection.includes(fieldName)) {
+                columnsToSelectInternal.push(child.fieldKey);
+            }
+            continue;
+        }
+        if (!child.relation)
+            continue;
+        if (child.type === 'm2o') {
+            columnsToSelectInternal.push(child.relation.field);
+        }
+        if (child.type === 'a2o') {
+            columnsToSelectInternal.push(child.relation.field);
+            columnsToSelectInternal.push(child.relation.meta.one_collection_field);
+        }
+        nestedCollectionNodes.push(child);
+    }
+    const isAggregate = (query.group || (query.aggregate && Object.keys(query.aggregate).length > 0)) ?? false;
+    /** Always fetch primary key in case there's a nested relation that needs it. Aggregate payloads
+     * can't have nested relational fields
+     */
+    if (isAggregate === false && columnsToSelectInternal.includes(primaryKeyField) === false) {
+        columnsToSelectInternal.push(primaryKeyField);
+    }
+    /** Make sure select list has unique values */
+    const columnsToSelect = [...new Set(columnsToSelectInternal)];
+    const fieldNodes = columnsToSelect.map((column) => children.find((childNode) => (childNode.type === 'field' || childNode.type === 'functionField') && childNode.fieldKey === column) ?? {
+        type: 'field',
+        name: column,
+        fieldKey: column,
+    });
+    return { fieldNodes, nestedCollectionNodes, primaryKeyField };
+}

package/dist/database/run-ast/run-ast.d.ts

@@ -0,0 +1,7 @@
+import type { Item, SchemaOverview } from '@directus/types';
+import type { AST, NestedCollectionNode } from '../../types/ast.js';
+import type { RunASTOptions } from './types.js';
+/**
+ * Execute a given AST using Knex. Returns array of items based on requested AST.
+ */
+export declare function runAst(originalAST: AST | NestedCollectionNode, schema: SchemaOverview, options?: RunASTOptions): Promise<null | Item | Item[]>;

package/dist/database/run-ast/run-ast.js

@@ -0,0 +1,107 @@
+import { useEnv } from '@directus/env';
+import { cloneDeep, merge } from 'lodash-es';
+import { PayloadService } from '../../services/payload.js';
+import getDatabase from '../index.js';
+import { getDBQuery } from './lib/get-db-query.js';
+import { parseCurrentLevel } from './lib/parse-current-level.js';
+import { applyParentFilters } from './utils/apply-parent-filters.js';
+import { mergeWithParentItems } from './utils/merge-with-parent-items.js';
+import { removeTemporaryFields } from './utils/remove-temporary-fields.js';
+/**
+ * Execute a given AST using Knex. Returns array of items based on requested AST.
+ */
+export async function runAst(originalAST, schema, options) {
+    const ast = cloneDeep(originalAST);
+    const knex = options?.knex || getDatabase();
+    if (ast.type === 'a2o') {
+        const results = {};
+        for (const collection of ast.names) {
+            results[collection] = await run(collection, ast.children[collection], ast.query[collection], ast.cases[collection] ?? []);
+        }
+        return results;
+    }
+    else {
+        return await run(ast.name, ast.children, options?.query || ast.query, ast.cases);
+    }
+    async function run(collection, children, query, cases) {
+        const env = useEnv();
+        // Retrieve the database columns to select in the current AST
+        const { fieldNodes, primaryKeyField, nestedCollectionNodes } = await parseCurrentLevel(schema, collection, children, query);
+        const o2mNodes = nestedCollectionNodes.filter((node) => node.type === 'o2m');
+        // The actual knex query builder instance. This is a promise that resolves with the raw items from the db
+        const dbQuery = getDBQuery(schema, knex, collection, fieldNodes, o2mNodes, query, cases);
+        const rawItems = await dbQuery;
+        if (!rawItems)
+            return null;
+        // Run the items through the special transforms
+        const payloadService = new PayloadService(collection, { knex, schema });
+        let items = await payloadService.processValues('read', rawItems, query.alias ?? {});
+        if (!items || (Array.isArray(items) && items.length === 0))
+            return items;
+        // Apply the `_in` filters to the nested collection batches
+        const nestedNodes = applyParentFilters(schema, nestedCollectionNodes, items);
+        for (const nestedNode of nestedNodes) {
+            let nestedItems = [];
+            if (nestedNode.type === 'o2m') {
+                let hasMore = true;
+                let batchCount = 0;
+                // If a nested node has a whenCase it indicates that the user might not be able to access the field for all items.
+                // In that case the queried item includes a flag under the fieldKey that is populated in the db and indicates
+                // if the user has access to that field for that specific item.
+                const hasWhenCase = nestedNode.whenCase && nestedNode.whenCase.length > 0;
+                let fieldAllowed = true;
+                if (hasWhenCase) {
+                    // Extract flag and remove field from item, so it can be populated with the actual items
+                    if (Array.isArray(items)) {
+                        fieldAllowed = [];
+                        for (const item of items) {
+                            fieldAllowed.push(!!item[nestedNode.fieldKey]);
+                            delete item[nestedNode.fieldKey];
+                        }
+                    }
+                    else {
+                        fieldAllowed = !!items[nestedNode.fieldKey];
+                        delete items[nestedNode.fieldKey];
+                    }
+                }
+                while (hasMore) {
+                    const node = merge({}, nestedNode, {
+                        query: {
+                            limit: env['RELATIONAL_BATCH_SIZE'],
+                            offset: batchCount * env['RELATIONAL_BATCH_SIZE'],
+                            page: null,
+                        },
+                    });
+                    nestedItems = (await runAst(node, schema, { knex, nested: true }));
+                    if (nestedItems) {
+                        items = mergeWithParentItems(schema, nestedItems, items, nestedNode, fieldAllowed);
+                    }
+                    if (!nestedItems || nestedItems.length < env['RELATIONAL_BATCH_SIZE']) {
+                        hasMore = false;
+                    }
+                    batchCount++;
+                }
+            }
+            else {
+                const node = merge({}, nestedNode, {
+                    query: { limit: -1 },
+                });
+                nestedItems = (await runAst(node, schema, { knex, nested: true }));
+                if (nestedItems) {
+                    // Merge all fetched nested records with the parent items
+                    items = mergeWithParentItems(schema, nestedItems, items, nestedNode, true);
+                }
+            }
+        }
+        // During the fetching of data, we have to inject a couple of required fields for the child nesting
+        // to work (primary / foreign keys) even if they're not explicitly requested. After all fetching
+        // and nesting is done, we parse through the output structure, and filter out all non-requested
+        // fields
+        // The field allowed flags injected in `getDBQuery` are already removed while processing the nested nodes in
+        // the previous step.
+        if (options?.nested !== true && options?.stripNonRequested !== false) {
+            items = removeTemporaryFields(schema, items, originalAST, primaryKeyField);
+        }
+        return items;
+    }
+}

package/dist/database/{run-ast.d.ts → run-ast/types.d.ts}

@@ -1,7 +1,6 @@
-import type { Item, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { AST, NestedCollectionNode } from '../types/ast.js';
-type RunASTOptions = {
+import type { AST } from '../../types/ast.js';
+export interface RunASTOptions {
     /**
      * Query override for the current level
      */
@@ -18,9 +17,4 @@ type RunASTOptions = {
      * Whether or not to strip out non-requested required fields automatically (eg IDs / FKs)
      */
     stripNonRequested?: boolean;
-};
-/**
- * Execute a given AST using Knex. Returns array of items based on requested AST.
- */
-export default function runAST(originalAST: AST | NestedCollectionNode, schema: SchemaOverview, options?: RunASTOptions): Promise<null | Item | Item[]>;
-export {};
+}

package/dist/database/run-ast/types.js

@@ -0,0 +1 @@
+export {};

package/dist/database/run-ast/utils/apply-case-when.d.ts

@@ -0,0 +1,16 @@
+import type { Filter, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { AliasMap } from '../../../utils/get-column-path.js';
+export interface ApplyCaseWhenOptions {
+    column: Knex.Raw;
+    columnCases: Filter[];
+    table: string;
+    cases: Filter[];
+    aliasMap: AliasMap;
+    alias?: string;
+}
+export interface ApplyCaseWhenContext {
+    knex: Knex;
+    schema: SchemaOverview;
+}
+export declare function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias }: ApplyCaseWhenOptions, { knex, schema }: ApplyCaseWhenContext): Knex.Raw;

package/dist/database/run-ast/utils/apply-case-when.js

@@ -0,0 +1,26 @@
+import { applyFilter } from '../../../utils/apply-query.js';
+export function applyCaseWhen({ columnCases, table, aliasMap, cases, column, alias }, { knex, schema }) {
+    const caseQuery = knex.queryBuilder();
+    applyFilter(knex, schema, caseQuery, { _or: columnCases }, table, aliasMap, cases);
+    const compiler = knex.client.queryCompiler(caseQuery);
+    const sqlParts = [];
+    // Only empty filters, so no where was generated, skip it
+    if (!compiler.grouped.where)
+        return column;
+    for (const statement of compiler.grouped.where) {
+        const val = compiler[statement.type](statement);
+        if (val) {
+            if (sqlParts.length > 0) {
+                sqlParts.push(statement.bool);
+            }
+            sqlParts.push(val);
+        }
+    }
+    const sql = sqlParts.join(' ');
+    const bindings = caseQuery.toSQL().bindings;
+    const result = knex.raw(`(CASE WHEN ${sql} THEN ?? END)`, [...bindings, column]);
+    if (alias) {
+        return knex.raw(result + ' AS ??', [alias]);
+    }
+    return result;
+}

package/dist/database/run-ast/utils/apply-parent-filters.d.ts

@@ -0,0 +1,3 @@
+import type { Item, SchemaOverview } from '@directus/types';
+import type { NestedCollectionNode } from '../../../types/ast.js';
+export declare function applyParentFilters(schema: SchemaOverview, nestedCollectionNodes: NestedCollectionNode[], parentItem: Item | Item[]): NestedCollectionNode[];

package/dist/database/run-ast/utils/apply-parent-filters.js

@@ -0,0 +1,55 @@
+import { toArray } from '@directus/utils';
+import { isNil, merge, uniq } from 'lodash-es';
+export function applyParentFilters(schema, nestedCollectionNodes, parentItem) {
+    const parentItems = toArray(parentItem);
+    for (const nestedNode of nestedCollectionNodes) {
+        if (!nestedNode.relation)
+            continue;
+        if (nestedNode.type === 'm2o') {
+            const foreignField = schema.collections[nestedNode.relation.related_collection].primary;
+            const foreignIds = uniq(parentItems.map((res) => res[nestedNode.relation.field])).filter((id) => !isNil(id));
+            merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });
+        }
+        else if (nestedNode.type === 'o2m') {
+            const relatedM2OisFetched = !!nestedNode.children.find((child) => {
+                return child.type === 'field' && child.name === nestedNode.relation.field;
+            });
+            if (relatedM2OisFetched === false) {
+                nestedNode.children.push({
+                    type: 'field',
+                    name: nestedNode.relation.field,
+                    fieldKey: nestedNode.relation.field,
+                    whenCase: [],
+                });
+            }
+            if (nestedNode.relation.meta?.sort_field) {
+                nestedNode.children.push({
+                    type: 'field',
+                    name: nestedNode.relation.meta.sort_field,
+                    fieldKey: nestedNode.relation.meta.sort_field,
+                    whenCase: [],
+                });
+            }
+            const foreignField = nestedNode.relation.field;
+            const foreignIds = uniq(parentItems.map((res) => res[nestedNode.parentKey])).filter((id) => !isNil(id));
+            merge(nestedNode, { query: { filter: { [foreignField]: { _in: foreignIds } } } });
+        }
+        else if (nestedNode.type === 'a2o') {
+            const keysPerCollection = {};
+            for (const parentItem of parentItems) {
+                const collection = parentItem[nestedNode.relation.meta.one_collection_field];
+                if (!keysPerCollection[collection])
+                    keysPerCollection[collection] = [];
+                keysPerCollection[collection].push(parentItem[nestedNode.relation.field]);
+            }
+            for (const relatedCollection of nestedNode.names) {
+                const foreignField = nestedNode.relatedKey[relatedCollection];
+                const foreignIds = uniq(keysPerCollection[relatedCollection]);
+                merge(nestedNode, {
+                    query: { [relatedCollection]: { filter: { [foreignField]: { _in: foreignIds } }, limit: foreignIds.length } },
+                });
+            }
+        }
+    }
+    return nestedCollectionNodes;
+}

package/dist/database/run-ast/utils/get-column-pre-processor.d.ts

@@ -0,0 +1,10 @@
+import type { Filter, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { FieldNode, FunctionFieldNode, M2ONode } from '../../../types/ast.js';
+import type { AliasMap } from '../../../utils/get-column-path.js';
+interface NodePreProcessOptions {
+    /** Don't assign an alias to the column but instead return the column as is */
+    noAlias?: boolean;
+}
+export declare function getColumnPreprocessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], aliasMap: AliasMap): (fieldNode: FieldNode | FunctionFieldNode | M2ONode, options?: NodePreProcessOptions) => Knex.Raw<string>;
+export {};

package/dist/database/run-ast/utils/get-column-pre-processor.js

@@ -0,0 +1,57 @@
+import { joinFilterWithCases } from '../../../utils/apply-query.js';
+import { getColumn } from '../../../utils/get-column.js';
+import { parseFilterKey } from '../../../utils/parse-filter-key.js';
+import { getHelpers } from '../../helpers/index.js';
+import { applyCaseWhen } from './apply-case-when.js';
+import { getNodeAlias } from './get-field-alias.js';
+export function getColumnPreprocessor(knex, schema, table, cases, aliasMap) {
+    const helpers = getHelpers(knex);
+    return function (fieldNode, options) {
+        // Don't assign an alias to the column expression if the field has a whenCase
+        // (since the alias will be assigned in applyCaseWhen) or if the noAlias option is set
+        const hasWhenCase = fieldNode.whenCase && fieldNode.whenCase.length > 0;
+        const noAlias = options?.noAlias || hasWhenCase;
+        const alias = getNodeAlias(fieldNode);
+        const rawColumnAlias = noAlias ? false : alias;
+        let field;
+        if (fieldNode.type === 'field' || fieldNode.type === 'functionField') {
+            const { fieldName } = parseFilterKey(fieldNode.name);
+            field = schema.collections[table].fields[fieldName];
+        }
+        else {
+            field = schema.collections[fieldNode.relation.collection].fields[fieldNode.relation.field];
+        }
+        let column;
+        if (field?.type?.startsWith('geometry')) {
+            column = helpers.st.asText(table, field.field, rawColumnAlias);
+        }
+        else if (fieldNode.type === 'functionField') {
+            // Include the field cases in the functionField query filter
+            column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema, {
+                query: {
+                    ...fieldNode.query,
+                    filter: joinFilterWithCases(fieldNode.query.filter, fieldNode.cases),
+                },
+                cases: fieldNode.cases,
+            });
+        }
+        else {
+            column = getColumn(knex, table, fieldNode.name, rawColumnAlias, schema);
+        }
+        if (hasWhenCase) {
+            const columnCases = [];
+            for (const index of fieldNode.whenCase) {
+                columnCases.push(cases[index]);
+            }
+            column = applyCaseWhen({
+                column,
+                columnCases,
+                aliasMap,
+                cases,
+                table,
+                alias,
+            }, { knex, schema });
+        }
+        return column;
+    };
+}

package/dist/database/run-ast/utils/get-field-alias.d.ts

@@ -0,0 +1,2 @@
+import type { FieldNode, FunctionFieldNode, M2ONode, O2MNode } from '../../../types/index.js';
+export declare function getNodeAlias(node: FieldNode | FunctionFieldNode | M2ONode | O2MNode): string;

package/dist/database/run-ast/utils/get-field-alias.js

@@ -0,0 +1,4 @@
+import { applyFunctionToColumnName } from '../../../utils/apply-function-to-column-name.js';
+export function getNodeAlias(node) {
+    return applyFunctionToColumnName(node.fieldKey);
+}

package/dist/database/run-ast/utils/get-inner-query-column-pre-processor.d.ts

@@ -0,0 +1,5 @@
+import type { Filter, SchemaOverview } from '@directus/types';
+import type { Knex } from 'knex';
+import type { FieldNode, FunctionFieldNode, M2ONode, O2MNode } from '../../../types/index.js';
+import type { AliasMap } from '../../../utils/get-column-path.js';
+export declare function getInnerQueryColumnPreProcessor(knex: Knex, schema: SchemaOverview, table: string, cases: Filter[], aliasMap: AliasMap, aliasPrefix: string): (fieldNode: FieldNode | FunctionFieldNode | M2ONode | O2MNode) => Knex.Raw<string> | null;

package/dist/database/run-ast/utils/get-inner-query-column-pre-processor.js

@@ -0,0 +1,23 @@
+import { applyCaseWhen } from './apply-case-when.js';
+import { getNodeAlias } from './get-field-alias.js';
+export function getInnerQueryColumnPreProcessor(knex, schema, table, cases, aliasMap, aliasPrefix) {
+    return function (fieldNode) {
+        const alias = getNodeAlias(fieldNode);
+        if (fieldNode.whenCase && fieldNode.whenCase.length > 0) {
+            const columnCases = [];
+            for (const index of fieldNode.whenCase) {
+                columnCases.push(cases[index]);
+            }
+            // Don't pass in the alias as we need to wrap the whole case/when in a count() an alias that
+            const caseWhen = applyCaseWhen({
+                column: knex.raw(1),
+                columnCases,
+                aliasMap,
+                cases,
+                table,
+            }, { knex, schema });
+            return knex.raw('COUNT(??) AS ??', [caseWhen, `${aliasPrefix}_${alias}`]);
+        }
+        return null;
+    };
+}

package/dist/database/run-ast/utils/merge-with-parent-items.d.ts

@@ -0,0 +1,3 @@
+import type { Item, SchemaOverview } from '@directus/types';
+import type { NestedCollectionNode } from '../../../types/ast.js';
+export declare function mergeWithParentItems(schema: SchemaOverview, nestedItem: Item | Item[], parentItem: Item | Item[], nestedNode: NestedCollectionNode, fieldAllowed: boolean | boolean[]): Item | Item[] | undefined;