@directus/api 20.0.0-rc.0 → 20.0.0

package/dist/database/migrations/20240619A-permissions-policies.js

@@ -1,163 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { processChunk } from '@directus/utils';
-/**
- * The public role used to be `null`, we gotta create a single new policy for the permissions
- * previously attached to the public role (marked through `role = null`).
- */
-const PUBLIC_POLICY_ID = 'abf8a154-5b1c-4a46-ac9c-7300570f4f17';
-export async function up(knex) {
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Create new policies table that mirrors previous Roles
-    await knex.schema.createTable('directus_policies', (table) => {
-        table.uuid('id').primary();
-        table.string('name', 100).notNullable();
-        table.string('icon', 64).notNullable().defaultTo('badge');
-        table.text('description');
-        table.text('ip_access');
-        table.boolean('enforce_tfa').defaultTo(false).notNullable();
-        table.boolean('admin_access').defaultTo(false).notNullable();
-        table.boolean('app_access').defaultTo(false).notNullable();
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Copy over all existing roles into new policies
-    const roles = await knex
-        .select('id', 'name', 'icon', 'description', 'ip_access', 'enforce_tfa', 'admin_access', 'app_access')
-        .from('directus_roles');
-    if (roles.length > 0) {
-        await processChunk(roles, 100, async (chunk) => {
-            await knex('directus_policies').insert(chunk);
-        });
-    }
-    await knex
-        .insert({
-        id: PUBLIC_POLICY_ID,
-        name: '$t:public_label',
-        icon: 'public',
-        description: '$t:public_description',
-        app_access: false,
-    })
-        .into('directus_policies');
-    // Change the admin policy description to $t:admin_policy_description
-    await knex('directus_policies')
-        .update({
-        description: '$t:admin_policy_description',
-    })
-        .where('description', 'LIKE', '$t:admin_description');
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Remove access control + add nesting to roles
-    await knex.schema.alterTable('directus_roles', (table) => {
-        table.dropColumn('ip_access');
-        table.dropColumn('enforce_tfa');
-        table.dropColumn('admin_access');
-        table.dropColumn('app_access');
-        table.uuid('parent').references('directus_roles.id');
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Link permissions to policies instead of roles
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.uuid('policy').notNullable().references('directus_policies.id').onDelete('CASCADE');
-        // Drop the foreign key constraint here in order to update `null` role to public policy ID
-        table.dropForeign('role');
-    });
-    await knex('directus_permissions')
-        .update({
-        role: PUBLIC_POLICY_ID,
-    })
-        .whereNull('role');
-    await knex('directus_permissions').update({
-        policy: knex.ref('role'),
-    });
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.dropColumns('role');
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Setup junction table between roles/users and policies
-    // This could be a A2O style setup with a collection/item field rather than individual foreign
-    // keys, but we want to be able to show the reverse-relationship on the individual policies as
-    // well, which would require the O2A type to exist in Directus which currently doesn't.
-    // Shouldn't be the end of the world here, as we know we're only attaching policies to two other
-    // collections.
-    await knex.schema.createTable('directus_access', (table) => {
-        table.uuid('id').primary();
-        table.uuid('role').references('directus_roles.id').nullable().onDelete('CASCADE');
-        table.uuid('user').references('directus_users.id').nullable().onDelete('CASCADE');
-        table.uuid('policy').references('directus_policies.id').notNullable().onDelete('CASCADE');
-        table.integer('sort');
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Attach policies to existing roles for backwards compatibility
-    const policyAttachments = roles.map((role) => ({
-        id: randomUUID(),
-        role: role.id,
-        user: null,
-        policy: role.id,
-        sort: 1,
-    }));
-    await processChunk(policyAttachments, 100, async (chunk) => {
-        await knex('directus_access').insert(chunk);
-    });
-    await knex('directus_access').insert({
-        id: randomUUID(),
-        role: null,
-        user: null,
-        policy: PUBLIC_POLICY_ID,
-        sort: 1,
-    });
-}
-export async function down(knex) {
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Reinstate access control fields on directus roles + remove nesting
-    await knex.schema.alterTable('directus_roles', (table) => {
-        table.text('ip_access');
-        table.boolean('enforce_tfa').defaultTo(false).notNullable();
-        table.boolean('admin_access').defaultTo(false).notNullable();
-        table.boolean('app_access').defaultTo(true).notNullable();
-        table.dropForeign('parent');
-        table.dropColumn('parent');
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Copy policy access control rules back to roles
-    const policies = await knex
-        .select('id', 'ip_access', 'enforce_tfa', 'admin_access', 'app_access')
-        .from('directus_policies')
-        .whereNot({ id: PUBLIC_POLICY_ID });
-    for (const policy of policies) {
-        await knex('directus_roles')
-            .update({
-            ip_access: policy.ip_access,
-            enforce_tfa: policy.enforce_tfa,
-            admin_access: policy.admin_access,
-            app_access: policy.app_access,
-        })
-            .where({ id: policy.id });
-    }
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Drop all permissions that are only attached to a user
-    // TODO query all policies that are attached to a user and delete their permissions,
-    //  since we don't know were to put them now and it'll cause a foreign key problem
-    //  as soon as we reference directus_roles in directus_permissions again
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Drop policy attachments
-    await knex.schema.dropTable('directus_access');
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Reattach permissions to roles instead of policies
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.uuid('role').nullable();
-    });
-    await knex('directus_permissions').update({
-        role: knex.ref('policy'),
-    });
-    await knex('directus_permissions')
-        .update({
-        role: null,
-    })
-        .where({ role: PUBLIC_POLICY_ID });
-    await knex.schema.alterTable('directus_permissions', (table) => {
-        table.uuid('role').references('directus_roles.id').alter();
-        table.dropForeign('policy');
-        table.dropColumn('policy');
-    });
-    /////////////////////////////////////////////////////////////////////////////////////////////////
-    // Drop policies table
-    await knex.schema.dropTable('directus_policies');
-}

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

@@ -1,4 +0,0 @@
-import type { Filter, Query, SchemaOverview } from '@directus/types';
-import type { Knex } from 'knex';
-import type { FieldNode, FunctionFieldNode, O2MNode } from '../../../types/ast.js';
-export declare function getDBQuery(schema: SchemaOverview, knex: Knex, table: string, fieldNodes: (FieldNode | FunctionFieldNode)[], o2mNodes: O2MNode[], query: Query, cases: Filter[]): Knex.QueryBuilder;

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

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

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

@@ -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;
-}