@directus/api 20.0.0-rc.0 → 20.0.0

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

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

@@ -1,7 +0,0 @@
-import type { Accountability } from '@directus/types';
-import type { Context } from '../types.js';
-export declare const fetchPolicies: typeof _fetchPolicies;
-/**
- * Fetch the policies associated with the current user accountability
- */
-export declare function _fetchPolicies({ roles, user, ip }: Pick<Accountability, 'user' | 'roles' | 'ip'>, context: Context): Promise<string[]>;

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

@@ -1,28 +0,0 @@
-import { filterPoliciesByIp } from '../utils/filter-policies-by-ip.js';
-import { withCache } from '../utils/with-cache.js';
-export const fetchPolicies = withCache('policies', _fetchPolicies, ({ roles, user, ip }) => ({ roles, user, ip }));
-/**
- * Fetch the policies associated with the current user accountability
- */
-export async function _fetchPolicies({ roles, user, ip }, context) {
-    const { AccessService } = await import('../../services/access.js');
-    const accessService = new AccessService(context);
-    let roleFilter;
-    if (roles.length === 0) {
-        // Users without role assumes the Public role permissions along with their attached policies
-        roleFilter = { role: { _null: true }, user: { _null: true } };
-    }
-    else {
-        roleFilter = { role: { _in: roles } };
-    }
-    // If the user is not null, we also want to include the policies attached to the user
-    const filter = user ? { _or: [{ user: { _eq: user } }, roleFilter] } : roleFilter;
-    const accessRows = (await accessService.readByQuery({
-        filter,
-        fields: ['policy.id', 'policy.ip_access'],
-        limit: -1,
-    }));
-    const filteredAccessRows = filterPoliciesByIp(accessRows, ip);
-    const ids = filteredAccessRows.map(({ policy }) => policy.id);
-    return ids;
-}

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

@@ -1,3 +0,0 @@
-import type { Knex } from 'knex';
-export declare const fetchRolesTree: typeof _fetchRolesTree;
-export declare function _fetchRolesTree(start: string | null, knex: Knex): Promise<string[]>;

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

@@ -1,28 +0,0 @@
-import { withCache } from '../utils/with-cache.js';
-export const fetchRolesTree = withCache('roles-tree', _fetchRolesTree);
-export async function _fetchRolesTree(start, knex) {
-    if (!start)
-        return [];
-    let parent = start;
-    const roles = [];
-    while (parent) {
-        const role = await knex
-            .select('id', 'parent')
-            .from('directus_roles')
-            .where({ id: parent })
-            .first();
-        if (!role) {
-            break;
-        }
-        roles.push(role.id);
-        // Prevent infinite recursion loops
-        if (role.parent && roles.includes(role.parent) === true) {
-            roles.reverse();
-            const rolesStr = roles.map((role) => `"${role}"`).join('->');
-            throw new Error(`Recursion encountered: role "${role.id}" already exists in tree path ${rolesStr}`);
-        }
-        parent = role.parent;
-    }
-    roles.reverse();
-    return roles;
-}

package/dist/permissions/lib/with-app-minimal-permissions.js

@@ -1,10 +0,0 @@
-import { appAccessMinimalPermissions } from '@directus/system-data';
-import { cloneDeep } from 'lodash-es';
-import { filterItems } from '../../utils/filter-items.js';
-export function withAppMinimalPermissions(accountability, permissions, filter) {
-    if (accountability?.app === true) {
-        const filteredAppMinimalPermissions = cloneDeep(filterItems(appAccessMinimalPermissions, filter));
-        return [...permissions, ...filteredAppMinimalPermissions];
-    }
-    return permissions;
-}

package/dist/permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.d.ts

@@ -1,7 +0,0 @@
-import type { Accountability, CollectionAccess } from '@directus/types';
-import type { Context } from '../../types.js';
-/**
- * Get all permissions + minimal app permissions (if applicable) for the user + role in the current accountability.
- * The permissions will be filtered by IP access.
- */
-export declare function fetchAccountabilityCollectionAccess(accountability: Pick<Accountability, 'user' | 'roles' | 'role' | 'ip' | 'admin' | 'app'>, context: Context): Promise<CollectionAccess>;

package/dist/permissions/modules/fetch-accountability-collection-access/fetch-accountability-collection-access.js

@@ -1,56 +0,0 @@
-import { PERMISSION_ACTIONS } from '@directus/constants';
-import { mapValues, uniq } from 'lodash-es';
-import { fetchPermissions } from '../../lib/fetch-permissions.js';
-import { fetchPolicies } from '../../lib/fetch-policies.js';
-/**
- * Get all permissions + minimal app permissions (if applicable) for the user + role in the current accountability.
- * The permissions will be filtered by IP access.
- */
-export async function fetchAccountabilityCollectionAccess(accountability, context) {
-    if (accountability.admin) {
-        return mapValues(context.schema.collections, () => Object.fromEntries(PERMISSION_ACTIONS.map((action) => [
-            action,
-            {
-                access: 'full',
-                fields: ['*'],
-            },
-        ])));
-    }
-    const policies = await fetchPolicies(accountability, context);
-    const permissions = await fetchPermissions({ policies, accountability }, context);
-    const infos = {};
-    for (const perm of permissions) {
-        // Ensure that collection is in infos
-        if (!infos[perm.collection]) {
-            infos[perm.collection] = {
-                read: { access: 'none' },
-                create: { access: 'none' },
-                update: { access: 'none' },
-                delete: { access: 'none' },
-                share: { access: 'none' },
-            };
-        }
-        // Ensure that action with default values is in collection infos
-        if (infos[perm.collection][perm.action]?.access === 'none') {
-            // If a permissions is iterated over it means that the user has access to it, so set access to 'full'
-            // Set access to 'full' initially and refine that whenever a permission with filters is encountered
-            infos[perm.collection][perm.action].access = 'full';
-        }
-        const info = infos[perm.collection][perm.action];
-        // Set access to 'partial' if the permission has filters, which means that the user has conditional access
-        if (info.access === 'full' && perm.permissions && Object.keys(perm.permissions).length > 0) {
-            info.access = 'partial';
-        }
-        if (perm.fields && info.fields?.[0] !== '*') {
-            info.fields = uniq([...(info.fields || []), ...(perm.fields || [])]);
-            if (info.fields.includes('*')) {
-                info.fields = ['*'];
-            }
-        }
-        if (perm.presets) {
-            info.presets = { ...(info.presets ?? {}), ...perm.presets };
-        }
-    }
-    // TODO Should fields by null, undefined or and empty array if no access?
-    return infos;
-}

package/dist/permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.d.ts

@@ -1,3 +0,0 @@
-import type { Accountability, Globals } from '@directus/types';
-import type { Context } from '../../types.js';
-export declare function fetchAccountabilityPolicyGlobals(accountability: Pick<Accountability, 'user' | 'roles' | 'ip' | 'admin' | 'app'>, context: Context): Promise<Globals>;

package/dist/permissions/modules/fetch-accountability-policy-globals/fetch-accountability-policy-globals.js

@@ -1,16 +0,0 @@
-import { fetchPolicies } from '../../lib/fetch-policies.js';
-export async function fetchAccountabilityPolicyGlobals(accountability, context) {
-    const policies = await fetchPolicies(accountability, context);
-    // Policies are already filtered down by the accountability IP, so we don't need to check it again
-    const result = await context.knex
-        .select(1)
-        .from('directus_policies')
-        .whereIn('id', policies)
-        .where('enforce_tfa', true)
-        .first();
-    return {
-        app_access: accountability.app,
-        admin_access: accountability.admin,
-        enforce_tfa: !!result,
-    };
-}

package/dist/permissions/modules/fetch-allowed-collections/fetch-allowed-collections.d.ts

@@ -1,8 +0,0 @@
-import type { Accountability, PermissionsAction } from '@directus/types';
-import type { Context } from '../../types.js';
-export interface FetchAllowedCollectionsOptions {
-    action: PermissionsAction;
-    accountability: Pick<Accountability, 'user' | 'role' | 'roles' | 'ip' | 'admin' | 'app'>;
-}
-export declare const fetchAllowedCollections: typeof _fetchAllowedCollections;
-export declare function _fetchAllowedCollections({ action, accountability }: FetchAllowedCollectionsOptions, { knex, schema }: Context): Promise<string[]>;

package/dist/permissions/modules/fetch-allowed-collections/fetch-allowed-collections.js

@@ -1,24 +0,0 @@
-import { uniq } from 'lodash-es';
-import { fetchPolicies } from '../../lib/fetch-policies.js';
-import { withCache } from '../../utils/with-cache.js';
-import { fetchPermissions } from '../../lib/fetch-permissions.js';
-export const fetchAllowedCollections = withCache('allowed-collections', _fetchAllowedCollections, ({ action, accountability: { user, role, roles, ip, admin, app } }) => ({
-    action,
-    accountability: {
-        user,
-        role,
-        roles,
-        ip,
-        admin,
-        app,
-    },
-}));
-export async function _fetchAllowedCollections({ action, accountability }, { knex, schema }) {
-    if (accountability.admin) {
-        return Object.keys(schema.collections);
-    }
-    const policies = await fetchPolicies(accountability, { knex, schema });
-    const permissions = await fetchPermissions({ action, policies, accountability }, { knex, schema });
-    const collections = permissions.map(({ collection }) => collection);
-    return uniq(collections);
-}

package/dist/permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.d.ts

@@ -1,9 +0,0 @@
-import type { Accountability, PermissionsAction } from '@directus/types';
-import type { Context } from '../../types.js';
-export type FieldMap = Record<string, string[]>;
-export interface FetchAllowedFieldMapOptions {
-    accountability: Pick<Accountability, 'user' | 'role' | 'roles' | 'ip' | 'admin' | 'app'>;
-    action: PermissionsAction;
-}
-export declare const fetchAllowedFieldMap: typeof _fetchAllowedFieldMap;
-export declare function _fetchAllowedFieldMap({ accountability, action }: FetchAllowedFieldMapOptions, { knex, schema }: Context): Promise<FieldMap>;

package/dist/permissions/modules/fetch-allowed-field-map/fetch-allowed-field-map.js

@@ -1,31 +0,0 @@
-import { uniq } from 'lodash-es';
-import { fetchPolicies } from '../../lib/fetch-policies.js';
-import { withCache } from '../../utils/with-cache.js';
-import { fetchPermissions } from '../../lib/fetch-permissions.js';
-export const fetchAllowedFieldMap = withCache('allowed-field-map', _fetchAllowedFieldMap, ({ action, accountability: { user, role, roles, ip, admin, app } }) => ({
-    action,
-    accountability: { user, role, roles, ip, admin, app },
-}));
-export async function _fetchAllowedFieldMap({ accountability, action }, { knex, schema }) {
-    const fieldMap = {};
-    if (accountability.admin) {
-        for (const [collection, { fields }] of Object.entries(schema.collections)) {
-            fieldMap[collection] = Object.keys(fields);
-        }
-        return fieldMap;
-    }
-    const policies = await fetchPolicies(accountability, { knex, schema });
-    const permissions = await fetchPermissions({ action, policies, accountability }, { knex, schema });
-    for (const { collection, fields } of permissions) {
-        if (!fieldMap[collection]) {
-            fieldMap[collection] = [];
-        }
-        if (fields) {
-            fieldMap[collection].push(...fields);
-        }
-    }
-    for (const [collection, fields] of Object.entries(fieldMap)) {
-        fieldMap[collection] = uniq(fields);
-    }
-    return fieldMap;
-}

package/dist/permissions/modules/fetch-allowed-fields/fetch-allowed-fields.d.ts

@@ -1,16 +0,0 @@
-import type { Accountability, PermissionsAction } from '@directus/types';
-import type { Context } from '../../types.js';
-export interface FetchAllowedFieldsOptions {
-    collection: string;
-    action: PermissionsAction;
-    accountability: Pick<Accountability, 'user' | 'role' | 'roles' | 'ip' | 'app'>;
-}
-export declare const fetchAllowedFields: typeof _fetchAllowedFields;
-/**
- * Look up all fields that are allowed to be used for the given collection and action for the given
- * accountability object
- *
- * Done by looking up all available policies for the current accountability object, and reading all
- * permissions that exist for the collection+action+policy combination
- */
-export declare function _fetchAllowedFields({ accountability, action, collection }: FetchAllowedFieldsOptions, { knex, schema }: Context): Promise<string[]>;