@directus/api 24.0.1 → 25.0.1

package/dist/middleware/respond.js

@@ -1,6 +1,7 @@
 import { useEnv } from '@directus/env';
 import { parse as parseBytesConfiguration } from 'bytes';
 import { getCache, setCacheValue } from '../cache.js';
+import getDatabase from '../database/index.js';
 import { useLogger } from '../logger/index.js';
 import { ExportService } from '../services/import-export.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -9,6 +10,7 @@ import { getCacheKey } from '../utils/get-cache-key.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stringByteSize } from '../utils/get-string-byte-size.js';
+import { permissionsCachable } from '../utils/permissions-cachable.js';
 export const respond = asyncHandler(async (req, res) => {
     const env = useEnv();
     const logger = useLogger();
@@ -26,7 +28,11 @@ export const respond = asyncHandler(async (req, res) => {
         cache &&
         !req.sanitizedQuery.export &&
         res.locals['cache'] !== false &&
-        exceedsMaxSize === false) {
+        exceedsMaxSize === false &&
+        (await permissionsCachable(req.collection, {
+            knex: getDatabase(),
+            schema: req.schema,
+        }, req.accountability))) {
         const key = await getCacheKey(req);
         try {
             await setCacheValue(cache, key, res.locals['payload'], getMilliseconds(env['CACHE_TTL']));

package/dist/operations/condition/index.js

@@ -1,11 +1,16 @@
-import { validatePayload } from '@directus/utils';
 import { defineOperationApi } from '@directus/extensions';
+import { validatePayload } from '@directus/utils';
+import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 export default defineOperationApi({
     id: 'condition',
     handler: ({ filter }, { data }) => {
         const errors = validatePayload(filter, data, { requireAll: true });
         if (errors.length > 0) {
-            throw errors;
+            // sanitize and format errors
+            const validationErrors = errors
+                .map((error) => error.details.map((details) => new FailedValidationError(joiValidationErrorItemToErrorExtensions(details))))
+                .flat();
+            throw validationErrors;
         }
         else {
             return null;

package/dist/schedules/metrics.d.ts

@@ -0,0 +1,7 @@
+export declare function handleMetricsJob(): Promise<void>;
+/**
+ * Schedule the metric generation
+ *
+ * @returns Whether or not metrics has been initialized
+ */
+export default function schedule(): Promise<boolean>;

package/dist/schedules/metrics.js

@@ -0,0 +1,44 @@
+import { useEnv } from '@directus/env';
+import { toBoolean } from '@directus/utils';
+import { scheduleJob } from 'node-schedule';
+import { useLogger } from '../logger/index.js';
+import { useMetrics } from '../metrics/index.js';
+import { validateCron } from '../utils/schedule.js';
+const METRICS_LOCK_TIMEOUT = 10 * 60 * 1000; // 10 mins
+let lockedAt = 0;
+const logger = useLogger();
+const metrics = useMetrics();
+export async function handleMetricsJob() {
+    const now = Date.now();
+    if (lockedAt !== 0 && lockedAt > now - METRICS_LOCK_TIMEOUT) {
+        // ensure only generating metrics once per node
+        return;
+    }
+    lockedAt = Date.now();
+    try {
+        await metrics?.generate();
+    }
+    catch (err) {
+        logger.warn(`An error was thrown while attempting metric generation`);
+        logger.warn(err);
+    }
+    finally {
+        lockedAt = 0;
+    }
+}
+/**
+ * Schedule the metric generation
+ *
+ * @returns Whether or not metrics has been initialized
+ */
+export default async function schedule() {
+    const env = useEnv();
+    if (!toBoolean(env['METRICS_ENABLED'])) {
+        return false;
+    }
+    if (!validateCron(String(env['METRICS_SCHEDULE']))) {
+        return false;
+    }
+    scheduleJob('metrics', String(env['METRICS_SCHEDULE']), handleMetricsJob);
+    return true;
+}

package/dist/services/assets.d.ts

@@ -10,9 +10,14 @@ export declare class AssetsService {
     schema: SchemaOverview;
     filesService: FilesService;
     constructor(options: AbstractServiceOptions);
-    getAsset(id: string, transformation?: TransformationSet, range?: Range): Promise<{
+    getAsset(id: string, transformation?: TransformationSet, range?: Range, deferStream?: false): Promise<{
         stream: Readable;
         file: any;
         stat: Stat;
     }>;
+    getAsset(id: string, transformation?: TransformationSet, range?: Range, deferStream?: true): Promise<{
+        stream: () => Promise<Readable>;
+        file: any;
+        stat: Stat;
+    }>;
 }

package/dist/services/assets.js

@@ -28,7 +28,7 @@ export class AssetsService {
         this.schema = options.schema;
         this.filesService = new FilesService({ ...options, accountability: null });
     }
-    async getAsset(id, transformation, range) {
+    async getAsset(id, transformation, range, deferStream = false) {
         const storage = await getStorage();
         const publicSettings = await this.knex
             .select('project_logo', 'public_background', 'public_foreground', 'public_favicon')
@@ -99,8 +99,9 @@ export class AssetsService {
                 file.type = contentType(assetFilename) || null;
             }
             if (exists) {
+                const assetStream = () => storage.location(file.storage).read(assetFilename, { range });
                 return {
-                    stream: await storage.location(file.storage).read(assetFilename, { range }),
+                    stream: deferStream ? assetStream : await assetStream(),
                     file,
                     stat: await storage.location(file.storage).stat(assetFilename),
                 };
@@ -123,7 +124,6 @@ export class AssetsService {
                     reason: 'Server too busy',
                 });
             }
-            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             const transformer = getSharpInstance();
             transformer.timeout({
                 seconds: clamp(Math.round(getMilliseconds(env['ASSETS_TRANSFORM_TIMEOUT'], 0) / 1000), 1, 3600),
@@ -131,6 +131,7 @@ export class AssetsService {
             if (transforms.find((transform) => transform[0] === 'rotate') === undefined)
                 transformer.rotate();
             transforms.forEach(([method, ...args]) => transformer[method].apply(transformer, args));
+            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
             readStream.on('error', (e) => {
                 logger.error(e, `Couldn't transform file ${file.id}`);
                 readStream.unpipe(transformer);
@@ -152,16 +153,17 @@ export class AssetsService {
                     throw error;
                 }
             }
+            const assetStream = () => storage.location(file.storage).read(assetFilename, { range, version });
             return {
-                stream: await storage.location(file.storage).read(assetFilename, { range, version }),
+                stream: deferStream ? assetStream : await assetStream(),
                 stat: await storage.location(file.storage).stat(assetFilename),
                 file,
             };
         }
         else {
-            const readStream = await storage.location(file.storage).read(file.filename_disk, { range, version });
+            const assetStream = () => storage.location(file.storage).read(file.filename_disk, { range, version });
             const stat = await storage.location(file.storage).stat(file.filename_disk);
-            return { stream: readStream, file, stat };
+            return { stream: deferStream ? assetStream : await assetStream(), file, stat };
         }
     }
 }

package/dist/services/collections.js

@@ -15,6 +15,9 @@ import { getSchema } from '../utils/get-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
 import { FieldsService } from './fields.js';
+import { buildCollectionAndFieldRelations } from './fields/build-collection-and-field-relations.js';
+import { getCollectionMetaUpdates } from './fields/get-collection-meta-updates.js';
+import { getCollectionRelationList } from './fields/get-collection-relation-list.js';
 import { ItemsService } from './items.js';
 export class CollectionsService {
     knex;
@@ -478,7 +481,18 @@ export class CollectionsService {
                         accountability: this.accountability,
                         schema: this.schema,
                     });
-                    await trx('directus_fields').delete().where('collection', '=', collectionKey);
+                    const fieldItemsService = new ItemsService('directus_fields', {
+                        knex: trx,
+                        accountability: this.accountability,
+                        schema: this.schema,
+                    });
+                    await fieldItemsService.deleteByQuery({
+                        filter: {
+                            collection: { _eq: collectionKey },
+                        },
+                    }, {
+                        bypassEmitAction: (params) => opts?.bypassEmitAction ? opts.bypassEmitAction(params) : nestedActionEvents.push(params),
+                    });
                     await trx('directus_presets').delete().where('collection', '=', collectionKey);
                     const revisionsToDelete = await trx
                         .select('id')
@@ -494,6 +508,22 @@ export class CollectionsService {
                     await trx('directus_activity').delete().where('collection', '=', collectionKey);
                     await trx('directus_permissions').delete().where('collection', '=', collectionKey);
                     await trx('directus_relations').delete().where({ many_collection: collectionKey });
+                    const { collectionRelationTree, fieldToCollectionList } = await buildCollectionAndFieldRelations(this.schema.relations);
+                    const collectionRelationList = getCollectionRelationList(collectionKey, collectionRelationTree);
+                    // only process duplication fields if related collections have them
+                    if (collectionRelationList.size !== 0) {
+                        const collectionMetas = await trx
+                            .select('collection', 'archive_field', 'sort_field', 'item_duplication_fields')
+                            .from('directus_collections')
+                            .whereIn('collection', Array.from(collectionRelationList))
+                            .whereNotNull('item_duplication_fields');
+                        await Promise.all(Object.keys(this.schema.collections[collectionKey]?.fields ?? {}).map(async (fieldKey) => {
+                            const collectionMetaUpdates = getCollectionMetaUpdates(collectionKey, fieldKey, collectionMetas, this.schema.collections, fieldToCollectionList);
+                            for (const meta of collectionMetaUpdates) {
+                                await trx('directus_collections').update(meta.updates).where({ collection: meta.collection });
+                            }
+                        }));
+                    }
                     const relations = this.schema.relations.filter((relation) => {
                         return relation.collection === collectionKey || relation.related_collection === collectionKey;
                     });

package/dist/services/fields/build-collection-and-field-relations.d.ts

@@ -0,0 +1,21 @@
+import type { Relation } from '@directus/types';
+/**
+ * Builds two maps where collectionRelationTree is a map of collection to related collections
+ * and fieldToCollectionList is a map of field:collection to related collection.
+ *
+ * @example
+ * returns {
+ * 		collectionRelationTree: new Map([
+ * 			['B', new Set(['A'])],
+ * 			['A', new Set(['B'])],
+ * 		]),
+ * 		fieldToCollectionList: new Map([
+ * 			['B:b', 'A'],
+ * 			['A:a', 'B'],
+ * 		]),
+ * }
+ */
+export declare function buildCollectionAndFieldRelations(relations: Relation[]): {
+    collectionRelationTree: Map<string, Set<string>>;
+    fieldToCollectionList: Map<string, string>;
+};

package/dist/services/fields/build-collection-and-field-relations.js

@@ -0,0 +1,55 @@
+/**
+ * Builds two maps where collectionRelationTree is a map of collection to related collections
+ * and fieldToCollectionList is a map of field:collection to related collection.
+ *
+ * @example
+ * returns {
+ * 		collectionRelationTree: new Map([
+ * 			['B', new Set(['A'])],
+ * 			['A', new Set(['B'])],
+ * 		]),
+ * 		fieldToCollectionList: new Map([
+ * 			['B:b', 'A'],
+ * 			['A:a', 'B'],
+ * 		]),
+ * }
+ */
+export function buildCollectionAndFieldRelations(relations) {
+    // Map<Collection, Set<RelatedCollection>>
+    const collectionRelationTree = new Map();
+    // Map<Field:Collection, RelatedCollection>
+    const fieldToCollectionList = new Map();
+    for (const relation of relations) {
+        let relatedCollections = [];
+        if (relation.related_collection) {
+            relatedCollections.push(relation.related_collection);
+        }
+        else if (relation.meta?.one_collection_field && relation.meta?.one_allowed_collections) {
+            relatedCollections = relation.meta?.one_allowed_collections;
+        }
+        else {
+            // safe guard
+            continue;
+        }
+        for (const relatedCollection of relatedCollections) {
+            let fieldToCollectionListKey = relation.collection + ':' + relation.field;
+            const collectionList = collectionRelationTree.get(relatedCollection) ?? new Set();
+            collectionList.add(relation.collection);
+            // O2M can have outward duplication path
+            if (relation.meta?.one_field) {
+                const relatedfieldToCollectionListKey = relatedCollection + ':' + relation.meta.one_field;
+                const realatedCollectionList = collectionRelationTree.get(relation.collection) ?? new Set();
+                realatedCollectionList.add(relatedCollection);
+                fieldToCollectionList.set(relatedfieldToCollectionListKey, relation.collection);
+                collectionRelationTree.set(relation.collection, realatedCollectionList);
+            }
+            // m2a fields show as field:collection in duplication path
+            if (relation.meta?.one_allowed_collections) {
+                fieldToCollectionListKey += ':' + relatedCollection;
+            }
+            fieldToCollectionList.set(fieldToCollectionListKey, relatedCollection);
+            collectionRelationTree.set(relatedCollection, collectionList);
+        }
+    }
+    return { collectionRelationTree, fieldToCollectionList };
+}

package/dist/services/fields/get-collection-meta-updates.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionsOverview } from '@directus/types';
+import type { Knex } from 'knex';
+export declare function getCollectionMetaUpdates(collection: string, field: string, collectionMetas: {
+    archive_field?: null | string;
+    sort_field?: null | string;
+    item_duplication_fields?: null | string | string[];
+    collection: string;
+}[], collections: CollectionsOverview, fieldToCollectionList: Map<string, string>): {
+    collection: string;
+    updates: Record<string, Knex.Value>;
+}[];

package/dist/services/fields/get-collection-meta-updates.js

@@ -0,0 +1,72 @@
+import { parseJSON } from '@directus/utils';
+export function getCollectionMetaUpdates(collection, field, collectionMetas, collections, fieldToCollectionList) {
+    const collectionMetaUpdates = [];
+    for (const collectionMeta of collectionMetas) {
+        let hasUpdates = false;
+        const meta = {
+            collection: collectionMeta.collection,
+            updates: {},
+        };
+        if (collectionMeta.collection === collection) {
+            if (collectionMeta?.archive_field === field) {
+                meta.updates['archive_field'] = null;
+                hasUpdates = true;
+            }
+            if (collectionMeta?.sort_field === field) {
+                meta.updates['sort_field'] = null;
+                hasUpdates = true;
+            }
+        }
+        if (collectionMeta?.item_duplication_fields) {
+            const itemDuplicationPaths = typeof collectionMeta.item_duplication_fields === 'string'
+                ? parseJSON(collectionMeta.item_duplication_fields)
+                : collectionMeta.item_duplication_fields;
+            const updatedPaths = [];
+            for (const path of itemDuplicationPaths) {
+                const updatedPath = updateItemDuplicationPath(path, collectionMeta.collection, field, collection, collections, fieldToCollectionList);
+                if (updatedPath && updatedPath.length !== 0) {
+                    updatedPaths.push(updatedPath.join('.'));
+                }
+            }
+            // only add updates on change
+            if (updatedPaths.length !== itemDuplicationPaths.length) {
+                meta.updates['item_duplication_fields'] = updatedPaths.length !== 0 ? JSON.stringify(updatedPaths) : null;
+                hasUpdates = true;
+            }
+        }
+        if (hasUpdates) {
+            collectionMetaUpdates.push(meta);
+        }
+    }
+    return collectionMetaUpdates;
+}
+function updateItemDuplicationPath(path, root, field, collection, collections, fieldToCollectionList) {
+    let currentCollection = root;
+    const parts = path.split('.');
+    // if the field name is not present in the path we can skip processing as no possible match
+    if ([field, `.${field}`, `.${field}.`, `${field}.`].some((fieldPart) => path.includes(fieldPart)) === false) {
+        return parts;
+    }
+    const updatedParts = [];
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        // Invalid path for the field that is currently being removed
+        if (currentCollection === collection && part === field)
+            return;
+        const isLastPart = index === parts.length - 1;
+        const isLocalField = typeof collections[currentCollection]?.['fields'][part] !== 'undefined';
+        const nextCollectionNode = fieldToCollectionList.get(`${currentCollection}:${part}`);
+        // Invalid path for old deleted collections
+        if (!nextCollectionNode && !isLastPart)
+            return;
+        // Invalid path for old deleted fields
+        if (!nextCollectionNode && isLastPart && !isLocalField)
+            return;
+        // next/last path is relational
+        if (nextCollectionNode) {
+            currentCollection = nextCollectionNode;
+        }
+        updatedParts.push(part);
+    }
+    return updatedParts;
+}

package/dist/services/fields/get-collection-relation-list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a list of all related collections for a given collection.
+ * Or in math terms, returns the [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component) that a given node belongs to.
+ */
+export declare function getCollectionRelationList(collection: string, collectionRelationTree: Map<string, Set<string>>): Set<string>;

package/dist/services/fields/get-collection-relation-list.js

@@ -0,0 +1,28 @@
+import { isSystemCollection } from '@directus/system-data';
+/**
+ * Returns a list of all related collections for a given collection.
+ * Or in math terms, returns the [strongly connected component](https://en.wikipedia.org/wiki/Strongly_connected_component) that a given node belongs to.
+ */
+export function getCollectionRelationList(collection, collectionRelationTree) {
+    const collectionRelationList = new Set();
+    traverseCollectionRelationTree(collection);
+    return collectionRelationList;
+    function traverseCollectionRelationTree(root) {
+        const relationTree = collectionRelationTree.get(root);
+        if (!relationTree)
+            return;
+        for (const relationNode of relationTree) {
+            addRelationNode(relationNode);
+        }
+    }
+    function addRelationNode(node) {
+        // system collections cannot have duplication fields and therfore can be skipped
+        if (isSystemCollection(node))
+            return;
+        // skip circular reference and existing linked nodes
+        if (node === collection || collectionRelationList.has(node))
+            return;
+        collectionRelationList.add(node);
+        traverseCollectionRelationTree(node);
+    }
+}

package/dist/services/fields.js

@@ -20,6 +20,9 @@ import { getSchema } from '../utils/get-schema.js';
 import { sanitizeColumn } from '../utils/sanitize-schema.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { transaction } from '../utils/transaction.js';
+import { buildCollectionAndFieldRelations } from './fields/build-collection-and-field-relations.js';
+import { getCollectionMetaUpdates } from './fields/get-collection-meta-updates.js';
+import { getCollectionRelationList } from './fields/get-collection-relation-list.js';
 import { ItemsService } from './items.js';
 import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
@@ -58,7 +61,7 @@ export class FieldsService {
         if (!columnInfo) {
             columnInfo = await this.schemaInspector.columnInfo();
             if (schemaCacheIsEnabled) {
-                setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
+                await setCacheValue(this.schemaCache, 'columnInfo', columnInfo);
             }
         }
         if (collection) {
@@ -556,20 +559,22 @@ export class FieldsService {
                         table.dropColumn(field);
                     });
                 }
-                const collectionMeta = await trx
-                    .select('archive_field', 'sort_field')
+                const { collectionRelationTree, fieldToCollectionList } = await buildCollectionAndFieldRelations(this.schema.relations);
+                const collectionRelationList = getCollectionRelationList(collection, collectionRelationTree);
+                const collectionMetaQuery = trx
+                    .queryBuilder()
+                    .select('collection', 'archive_field', 'sort_field', 'item_duplication_fields')
                     .from('directus_collections')
-                    .where({ collection })
-                    .first();
-                const collectionMetaUpdates = {};
-                if (collectionMeta?.archive_field === field) {
-                    collectionMetaUpdates['archive_field'] = null;
-                }
-                if (collectionMeta?.sort_field === field) {
-                    collectionMetaUpdates['sort_field'] = null;
+                    .where({ collection });
+                if (collectionRelationList.size !== 0) {
+                    collectionMetaQuery.orWhere(function () {
+                        this.whereIn('collection', Array.from(collectionRelationList)).whereNotNull('item_duplication_fields');
+                    });
                 }
-                if (Object.keys(collectionMetaUpdates).length > 0) {
-                    await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
+                const collectionMetas = await collectionMetaQuery;
+                const collectionMetaUpdates = getCollectionMetaUpdates(collection, field, collectionMetas, this.schema.collections, fieldToCollectionList);
+                for (const meta of collectionMetaUpdates) {
+                    await trx('directus_collections').update(meta.updates).where({ collection: meta.collection });
                 }
                 // Cleanup directus_fields
                 const metaRow = await trx

package/dist/services/graphql/errors/format.d.ts

@@ -0,0 +1,6 @@
+import { type DirectusError } from '@directus/errors';
+import { GraphQLError } from 'graphql';
+/**
+ * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
+ */
+export declare function formatError(error: DirectusError | DirectusError[]): GraphQLError;

package/dist/services/graphql/errors/format.js

@@ -0,0 +1,14 @@
+import {} from '@directus/errors';
+import { GraphQLError } from 'graphql';
+import { set } from 'lodash-es';
+/**
+ * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
+ */
+export function formatError(error) {
+    if (Array.isArray(error)) {
+        set(error[0], 'extensions.code', error[0].code);
+        return new GraphQLError(error[0].message, undefined, undefined, undefined, undefined, error[0]);
+    }
+    set(error, 'extensions.code', error.code);
+    return new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
+}

package/dist/services/graphql/index.d.ts

@@ -1,17 +1,15 @@
-import { type DirectusError } from '@directus/errors';
-import type { Accountability, Filter, Item, Query, SchemaOverview } from '@directus/types';
-import type { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
-import { GraphQLError, GraphQLSchema } from 'graphql';
-import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
+import type { Accountability, Item, Query, SchemaOverview } from '@directus/types';
+import type { FormattedExecutionResult, GraphQLSchema } from 'graphql';
 import type { Knex } from 'knex';
 import type { AbstractServiceOptions, GraphQLParams } from '../../types/index.js';
+export type GQLScope = 'items' | 'system';
 export declare class GraphQLService {
     accountability: Accountability | null;
     knex: Knex;
     schema: SchemaOverview;
-    scope: 'items' | 'system';
+    scope: GQLScope;
     constructor(options: AbstractServiceOptions & {
-        scope: 'items' | 'system';
+        scope: GQLScope;
     });
     /**
      * Execute a GraphQL structure
@@ -23,12 +21,6 @@ export declare class GraphQLService {
     getSchema(): Promise<GraphQLSchema>;
     getSchema(type: 'schema'): Promise<GraphQLSchema>;
     getSchema(type: 'sdl'): Promise<GraphQLSchema | string>;
-    /**
-     * Generic resolver that's used for every "regular" items/system query. Converts the incoming GraphQL AST / fragments into
-     * Directus' query structure which is then executed by the services.
-     */
-    resolveQuery(info: GraphQLResolveInfo): Promise<Partial<Item> | null>;
-    resolveMutation(args: Record<string, any>, info: GraphQLResolveInfo): Promise<Partial<Item> | boolean | undefined>;
     /**
      * Execute the read action on the correct service. Checks for singleton as well.
      */
@@ -37,44 +29,4 @@ export declare class GraphQLService {
      * Upsert and read singleton item
      */
     upsertSingleton(collection: string, body: Record<string, any> | Record<string, any>[], query: Query): Promise<Partial<Item> | boolean>;
-    /**
-     * GraphQL's regular resolver `args` variable only contains the "top-level" arguments. Seeing that we convert the
-     * whole nested tree into one big query using Directus' own query resolver, we want to have a nested structure of
-     * arguments for the whole resolving tree, which can later be transformed into Directus' AST using `deep`.
-     * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
-     * of arguments
-     */
-    parseArgs(args: readonly ArgumentNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;
-    /**
-     * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
-     * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.
-     */
-    getQuery(rawQuery: Query, selections: readonly SelectionNode[], variableValues: GraphQLResolveInfo['variableValues']): Query;
-    /**
-     * Resolve the aggregation query based on the requested aggregated fields
-     */
-    getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[]): Query;
-    /**
-     * Replace functions from GraphQL format to Directus-Filter format
-     */
-    replaceFuncs(filter: Filter): Filter;
-    /**
-     * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
-     */
-    formatError(error: DirectusError | DirectusError[]): GraphQLError;
-    /**
-     * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
-     * Effectively merges the selections with the fragments used in those selections
-     */
-    replaceFragmentsInSelections(selections: readonly SelectionNode[] | undefined, fragments: Record<string, FragmentDefinitionNode>): readonly SelectionNode[] | null;
-    injectSystemResolvers(schemaComposer: SchemaComposer<GraphQLParams['contextValue']>, { CreateCollectionTypes, ReadCollectionTypes, UpdateCollectionTypes, }: {
-        CreateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        ReadCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-        UpdateCollectionTypes: Record<string, ObjectTypeComposer<any, any>>;
-    }, schema: {
-        create: SchemaOverview;
-        read: SchemaOverview;
-        update: SchemaOverview;
-        delete: SchemaOverview;
-    }): SchemaComposer<any>;
 }