@directus/api 21.0.0 → 22.1.0

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,27 @@
+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, column];
+    let rawCase = `(CASE WHEN ${sql} THEN ?? END)`;
+    if (alias) {
+        rawCase += ' AS ??';
+        bindings.push(alias);
+    }
+    return knex.raw(rawCase, bindings);
+}

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;

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

@@ -0,0 +1,87 @@
+import { useEnv } from '@directus/env';
+import { toArray } from '@directus/utils';
+import { clone, isArray } from 'lodash-es';
+export function mergeWithParentItems(schema, nestedItem, parentItem, nestedNode, fieldAllowed) {
+    const env = useEnv();
+    const nestedItems = toArray(nestedItem);
+    const parentItems = clone(toArray(parentItem));
+    if (nestedNode.type === 'm2o') {
+        for (const parentItem of parentItems) {
+            const itemChild = nestedItems.find((nestedItem) => {
+                return (nestedItem[schema.collections[nestedNode.relation.related_collection].primary] ==
+                    parentItem[nestedNode.relation.field]);
+            });
+            parentItem[nestedNode.fieldKey] = itemChild || null;
+        }
+    }
+    else if (nestedNode.type === 'o2m') {
+        for (const [index, parentItem] of parentItems.entries()) {
+            if (fieldAllowed === false || (isArray(fieldAllowed) && !fieldAllowed[index])) {
+                parentItem[nestedNode.fieldKey] = null;
+                continue;
+            }
+            if (!parentItem[nestedNode.fieldKey])
+                parentItem[nestedNode.fieldKey] = [];
+            const itemChildren = nestedItems.filter((nestedItem) => {
+                if (nestedItem === null)
+                    return false;
+                if (Array.isArray(nestedItem[nestedNode.relation.field]))
+                    return true;
+                return (nestedItem[nestedNode.relation.field] ==
+                    parentItem[schema.collections[nestedNode.relation.related_collection].primary] ||
+                    nestedItem[nestedNode.relation.field]?.[schema.collections[nestedNode.relation.related_collection].primary] == parentItem[schema.collections[nestedNode.relation.related_collection].primary]);
+            });
+            parentItem[nestedNode.fieldKey].push(...itemChildren);
+            const limit = nestedNode.query.limit ?? Number(env['QUERY_LIMIT_DEFAULT']);
+            if (nestedNode.query.page && nestedNode.query.page > 1) {
+                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(limit * (nestedNode.query.page - 1));
+            }
+            if (nestedNode.query.offset && nestedNode.query.offset >= 0) {
+                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(nestedNode.query.offset);
+            }
+            if (limit !== -1) {
+                parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].slice(0, limit);
+            }
+            parentItem[nestedNode.fieldKey] = parentItem[nestedNode.fieldKey].sort((a, b) => {
+                // This is pre-filled in get-ast-from-query
+                const sortField = nestedNode.query.sort[0];
+                let column = sortField;
+                let order = 'asc';
+                if (sortField.startsWith('-')) {
+                    column = sortField.substring(1);
+                    order = 'desc';
+                }
+                if (a[column] === b[column])
+                    return 0;
+                if (a[column] === null)
+                    return 1;
+                if (b[column] === null)
+                    return -1;
+                if (order === 'asc') {
+                    return a[column] < b[column] ? -1 : 1;
+                }
+                else {
+                    return a[column] < b[column] ? 1 : -1;
+                }
+            });
+        }
+    }
+    else if (nestedNode.type === 'a2o') {
+        for (const parentItem of parentItems) {
+            if (!nestedNode.relation.meta?.one_collection_field) {
+                parentItem[nestedNode.fieldKey] = null;
+                continue;
+            }
+            const relatedCollection = parentItem[nestedNode.relation.meta.one_collection_field];
+            if (!nestedItem[relatedCollection]) {
+                parentItem[nestedNode.fieldKey] = null;
+                continue;
+            }
+            const itemChild = nestedItem[relatedCollection].find((nestedItem) => {
+                return nestedItem[nestedNode.relatedKey[relatedCollection]] == parentItem[nestedNode.fieldKey];
+            });
+            parentItem[nestedNode.fieldKey] = itemChild || null;
+        }
+    }
+    return Array.isArray(parentItem) ? parentItems : parentItems[0];
+}

package/dist/database/run-ast/utils/remove-temporary-fields.d.ts

@@ -0,0 +1,3 @@
+import type { Item, SchemaOverview } from '@directus/types';
+import type { AST, NestedCollectionNode } from '../../../types/ast.js';
+export declare function removeTemporaryFields(schema: SchemaOverview, rawItem: Item | Item[], ast: AST | NestedCollectionNode, primaryKeyField: string, parentItem?: Item): null | Item | Item[];

package/dist/database/run-ast/utils/remove-temporary-fields.js

@@ -0,0 +1,73 @@
+import { toArray } from '@directus/utils';
+import { cloneDeep, pick } from 'lodash-es';
+import { applyFunctionToColumnName } from '../../../utils/apply-function-to-column-name.js';
+export function removeTemporaryFields(schema, rawItem, ast, primaryKeyField, parentItem) {
+    const rawItems = cloneDeep(toArray(rawItem));
+    const items = [];
+    if (ast.type === 'a2o') {
+        const fields = {};
+        const nestedCollectionNodes = {};
+        for (const relatedCollection of ast.names) {
+            if (!fields[relatedCollection])
+                fields[relatedCollection] = [];
+            if (!nestedCollectionNodes[relatedCollection])
+                nestedCollectionNodes[relatedCollection] = [];
+            for (const child of ast.children[relatedCollection]) {
+                if (child.type === 'field' || child.type === 'functionField') {
+                    fields[relatedCollection].push(child.name);
+                }
+                else {
+                    fields[relatedCollection].push(child.fieldKey);
+                    nestedCollectionNodes[relatedCollection].push(child);
+                }
+            }
+        }
+        for (const rawItem of rawItems) {
+            const relatedCollection = parentItem?.[ast.relation.meta.one_collection_field];
+            if (rawItem === null || rawItem === undefined)
+                return rawItem;
+            let item = rawItem;
+            for (const nestedNode of nestedCollectionNodes[relatedCollection]) {
+                item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, schema.collections[nestedNode.relation.collection].primary, item);
+            }
+            const fieldsWithFunctionsApplied = fields[relatedCollection].map((field) => applyFunctionToColumnName(field));
+            item =
+                fields[relatedCollection].length > 0 ? pick(rawItem, fieldsWithFunctionsApplied) : rawItem[primaryKeyField];
+            items.push(item);
+        }
+    }
+    else {
+        const fields = [];
+        const nestedCollectionNodes = [];
+        for (const child of ast.children) {
+            fields.push(child.fieldKey);
+            if (child.type !== 'field' && child.type !== 'functionField') {
+                nestedCollectionNodes.push(child);
+            }
+        }
+        // Make sure any requested aggregate fields are included
+        if (ast.query?.aggregate) {
+            for (const [operation, aggregateFields] of Object.entries(ast.query.aggregate)) {
+                if (!fields)
+                    continue;
+                if (operation === 'count' && aggregateFields.includes('*'))
+                    fields.push('count');
+                fields.push(...aggregateFields.map((field) => `${operation}.${field}`));
+            }
+        }
+        for (const rawItem of rawItems) {
+            if (rawItem === null || rawItem === undefined)
+                return rawItem;
+            let item = rawItem;
+            for (const nestedNode of nestedCollectionNodes) {
+                item[nestedNode.fieldKey] = removeTemporaryFields(schema, item[nestedNode.fieldKey], nestedNode, nestedNode.type === 'm2o'
+                    ? schema.collections[nestedNode.relation.related_collection].primary
+                    : schema.collections[nestedNode.relation.collection].primary, item);
+            }
+            const fieldsWithFunctionsApplied = fields.map((field) => applyFunctionToColumnName(field));
+            item = fields.length > 0 ? pick(rawItem, fieldsWithFunctionsApplied) : rawItem[primaryKeyField];
+            items.push(item);
+        }
+    }
+    return Array.isArray(rawItem) ? items : items[0];
+}

package/dist/database/run-ast/utils/with-preprocess-bindings.d.ts

@@ -0,0 +1,2 @@
+import type { Knex } from 'knex';
+export declare function withPreprocessBindings(knex: Knex, dbQuery: Knex.QueryBuilder): void;

package/dist/database/run-ast/utils/with-preprocess-bindings.js

@@ -0,0 +1,14 @@
+import { getHelpers } from '../../helpers/index.js';
+export function withPreprocessBindings(knex, dbQuery) {
+    const schemaHelper = getHelpers(knex).schema;
+    dbQuery.client = new Proxy(dbQuery.client, {
+        get(target, prop, receiver) {
+            if (prop === 'query') {
+                return (connection, queryParam) => {
+                    return Reflect.get(target, prop, receiver).bind(target)(connection, schemaHelper.preprocessBindings(queryParam));
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}

package/dist/flows.js

@@ -1,8 +1,9 @@
 import { Action } from '@directus/constants';
 import { useEnv } from '@directus/env';
 import { ForbiddenError } from '@directus/errors';
+import { isSystemCollection } from '@directus/system-data';
 import { applyOptionsData, getRedactedString, isValidJSON, parseJSON, toArray } from '@directus/utils';
-import { omit, pick } from 'lodash-es';
+import { pick } from 'lodash-es';
 import { get } from 'micromustache';
 import { useBus } from './bus/index.js';
 import getDatabase from './database/index.js';
@@ -18,7 +19,6 @@ import { JobQueue } from './utils/job-queue.js';
 import { mapValuesDeep } from './utils/map-values-deep.js';
 import { redactObject } from './utils/redact-object.js';
 import { scheduleSynchronizedJob, validateCron } from './utils/schedule.js';
-import { isSystemCollection } from '@directus/system-data';
 let flowManager;
 export function getFlowManager() {
     if (flowManager) {
@@ -284,8 +284,7 @@ class FlowManager {
                     item: flow.id,
                     data: {
                         steps: steps.map((step) => redactObject(step, { values: this.envs }, getRedactedString)),
-                        data: redactObject(omit(keyedData, '$accountability.permissions'), // Permissions is a ton of data, and is just a copy of what's in the directus_permissions table
-                        {
+                        data: redactObject(keyedData, {
                             keys: [
                                 ['**', 'headers', 'authorization'],
                                 ['**', 'headers', 'cookie'],

package/dist/middleware/authenticate.js

@@ -1,6 +1,7 @@
 import { isEqual } from 'lodash-es';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
+import { createDefaultAccountability } from '../permissions/utils/create-default-accountability.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getAccountabilityForToken } from '../utils/get-accountability-for-token.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
@@ -12,13 +13,7 @@ import { SESSION_COOKIE_OPTIONS } from '../constants.js';
  */
 export const handler = async (req, res, next) => {
     const env = useEnv();
-    const defaultAccountability = {
-        user: null,
-        role: null,
-        admin: false,
-        app: false,
-        ip: getIPFromReq(req),
-    };
+    const defaultAccountability = createDefaultAccountability({ ip: getIPFromReq(req) });
     const userAgent = req.get('user-agent')?.substring(0, 1024);
     if (userAgent)
         defaultAccountability.userAgent = userAgent;