@directus/api 21.0.0-rc.0 → 21.0.0

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

@@ -1,41 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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/types.js

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

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

@@ -1,16 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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/permissions/cache.d.ts

@@ -1,2 +0,0 @@
-export declare const useCache: () => import("@directus/memory").Cache;
-export declare function clearCache(): Promise<void>;

package/dist/permissions/cache.js

@@ -1,23 +0,0 @@
-import { defineCache } from '@directus/memory';
-import { redisConfigAvailable, useRedis } from '../redis/index.js';
-const localOnly = redisConfigAvailable() === false;
-const config = localOnly
-    ? {
-        type: 'local',
-        maxKeys: 500,
-    }
-    : {
-        type: 'multi',
-        redis: {
-            namespace: 'permissions',
-            redis: useRedis(),
-        },
-        local: {
-            maxKeys: 100,
-        },
-    };
-export const useCache = defineCache(config);
-export function clearCache() {
-    const cache = useCache();
-    return cache.clear();
-}

package/dist/permissions/lib/fetch-permissions.d.ts

@@ -1,10 +0,0 @@
-import type { Accountability, Permission, PermissionsAction } from '@directus/types';
-import type { Context } from '../types.js';
-export declare const fetchPermissions: typeof _fetchPermissions;
-export interface FetchPermissionsOptions {
-    action?: PermissionsAction;
-    policies: string[];
-    collections?: string[];
-    accountability?: Pick<Accountability, 'user' | 'role' | 'roles' | 'app'>;
-}
-export declare function _fetchPermissions(options: FetchPermissionsOptions, context: Context): Promise<Permission[]>;

package/dist/permissions/lib/fetch-permissions.js

@@ -1,55 +0,0 @@
-import { pick, sortBy } from 'lodash-es';
-import { fetchDynamicVariableContext } from '../utils/fetch-dynamic-variable-context.js';
-import { processPermissions } from '../utils/process-permissions.js';
-import { withCache } from '../utils/with-cache.js';
-import { withAppMinimalPermissions } from './with-app-minimal-permissions.js';
-export const fetchPermissions = withCache('permissions', _fetchPermissions, ({ action, policies, collections, accountability }) => ({
-    policies, // we assume that policies always come from the same source, so they should be in the same order
-    ...(action && { action }),
-    ...(collections && { collections: sortBy(collections) }),
-    ...(accountability && { accountability: pick(accountability, ['user', 'role', 'roles', 'app']) }),
-}));
-export async function _fetchPermissions(options, context) {
-    const { PermissionsService } = await import('../../services/permissions.js');
-    const permissionsService = new PermissionsService(context);
-    const filter = {
-        _and: [{ policy: { _in: options.policies } }],
-    };
-    if (options.action) {
-        filter._and.push({ action: { _eq: options.action } });
-    }
-    if (options.collections) {
-        filter._and.push({ collection: { _in: options.collections } });
-    }
-    let permissions = (await permissionsService.readByQuery({
-        filter,
-        limit: -1,
-    }));
-    // Sort permissions by their order in the policies array
-    // This ensures that if a sorted array of policies is passed in the permissions are returned in the same order
-    // which is necessary for correctly applying the presets in order
-    permissions = sortBy(permissions, (permission) => options.policies.indexOf(permission.policy));
-    if (options.accountability) {
-        // Add app minimal permissions for the request accountability, if applicable.
-        // Normally this is done in the permissions service readByQuery, but it also needs to do it here
-        // since the permissions service is created without accountability.
-        // We call it without the policies filter, since the static minimal app permissions don't have a policy attached.
-        const permissionsWithAppPermissions = withAppMinimalPermissions(options.accountability ?? null, permissions, {
-            _and: filter._and.slice(1),
-        });
-        const permissionsContext = await fetchDynamicVariableContext({
-            accountability: options.accountability,
-            policies: options.policies,
-            permissions: permissionsWithAppPermissions,
-        }, context);
-        // Replace dynamic variables with their actual values
-        const processedPermissions = processPermissions({
-            permissions: permissionsWithAppPermissions,
-            accountability: options.accountability,
-            permissionsContext,
-        });
-        // TODO merge in permissions coming from the share scope
-        return processedPermissions;
-    }
-    return permissions;
-}