@directus/api 31.0.0 → 32.0.0

package/dist/services/fields.js

@@ -2,8 +2,10 @@ import { DEFAULT_NUMERIC_PRECISION, DEFAULT_NUMERIC_SCALE, KNEX_TYPES, REGEX_BET
 import { useEnv } from '@directus/env';
 import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
 import { createInspector } from '@directus/schema';
+import { isSystemField } from '@directus/system-data';
 import { addFieldFlag, getRelations, toArray } from '@directus/utils';
 import { isEqual, isNil, merge } from 'lodash-es';
+import { z } from 'zod';
 import { clearSystemCache, getCache, getCacheValue, setCacheValue } from '../cache.js';
 import { ALIAS_TYPES, ALLOWED_DB_DEFAULT_FUNCTIONS } from '../constants.js';
 import { translateDatabaseError } from '../database/errors/translate.js';
@@ -28,6 +30,17 @@ import { PayloadService } from './payload.js';
 import { RelationsService } from './relations.js';
 const systemFieldRows = getSystemFieldRowsWithAuthProviders();
 const env = useEnv();
+export const systemFieldUpdateSchema = z
+    .object({
+    collection: z.string().optional(),
+    field: z.string().optional(),
+    schema: z
+        .object({
+        is_indexed: z.boolean().optional(),
+    })
+        .strict(),
+})
+    .strict();
 export class FieldsService {
     knex;
     helpers;
@@ -89,14 +102,14 @@ export class FieldsService {
             schema: this.schema,
         });
         if (collection) {
-            fields = (await nonAuthorizedItemsService.readByQuery({
+            fields = await nonAuthorizedItemsService.readByQuery({
                 filter: { collection: { _eq: collection } },
                 limit: -1,
-            }));
+            });
             fields.push(...systemFieldRows.filter((fieldMeta) => fieldMeta.collection === collection));
         }
         else {
-            fields = (await nonAuthorizedItemsService.readByQuery({ limit: -1 }));
+            fields = await nonAuthorizedItemsService.readByQuery({ limit: -1 });
             fields.push(...systemFieldRows);
         }
         const columns = (await this.columnInfo(collection)).map((column) => ({
@@ -269,28 +282,35 @@ export class FieldsService {
             if (flagToAdd) {
                 addFieldFlag(field, flagToAdd);
             }
+            let hookAdjustedField = field;
+            const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
             await transaction(this.knex, async (trx) => {
                 const itemsService = new ItemsService('directus_fields', {
                     knex: trx,
                     accountability: this.accountability,
                     schema: this.schema,
                 });
-                const hookAdjustedField = opts?.emitEvents !== false
-                    ? await emitter.emitFilter(`fields.create`, field, {
-                        collection: collection,
-                    }, {
-                        database: trx,
-                        schema: this.schema,
-                        accountability: this.accountability,
-                    })
-                    : field;
+                hookAdjustedField =
+                    opts?.emitEvents !== false
+                        ? await emitter.emitFilter(`fields.create`, field, {
+                            collection: collection,
+                        }, {
+                            database: trx,
+                            schema: this.schema,
+                            accountability: this.accountability,
+                        })
+                        : field;
                 if (hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
                     if (table) {
-                        this.addColumnToTable(table, collection, hookAdjustedField);
+                        this.addColumnToTable(table, collection, hookAdjustedField, {
+                            attemptConcurrentIndex,
+                        });
                     }
                     else {
                         await trx.schema.alterTable(collection, (table) => {
-                            this.addColumnToTable(table, collection, hookAdjustedField);
+                            this.addColumnToTable(table, collection, hookAdjustedField, {
+                                attemptConcurrentIndex,
+                            });
                         });
                     }
                 }
@@ -327,6 +347,12 @@ export class FieldsService {
                     nestedActionEvents.push(actionEvent);
                 }
             });
+            // concurrent index creation cannot be done inside the transaction
+            if (attemptConcurrentIndex && hookAdjustedField.type && ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
+                await this.addColumnIndex(collection, hookAdjustedField, {
+                    attemptConcurrentIndex,
+                });
+            }
         }
         finally {
             if (runPostColumnChange) {
@@ -390,20 +416,32 @@ export class FieldsService {
                 const columnToCompare = opts?.bypassLimits && opts.autoPurgeSystemCache === false ? sanitizeColumn(existingColumn) : existingColumn;
                 if (!isEqual(columnToCompare, hookAdjustedField.schema)) {
                     try {
+                        const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
                         await transaction(this.knex, async (trx) => {
-                            await trx.schema.alterTable(collection, async (table) => {
+                            await trx.schema.alterTable(collection, (table) => {
                                 if (!hookAdjustedField.schema)
                                     return;
-                                this.addColumnToTable(table, collection, field, existingColumn);
+                                this.addColumnToTable(table, collection, field, {
+                                    existing: existingColumn,
+                                    attemptConcurrentIndex,
+                                });
                             });
                         });
+                        // concurrent index creation cannot be done inside the transaction
+                        if (attemptConcurrentIndex) {
+                            await this.addColumnIndex(collection, field, {
+                                existing: existingColumn,
+                                attemptConcurrentIndex,
+                            });
+                        }
                     }
                     catch (err) {
                         throw await translateDatabaseError(err, field);
                     }
                 }
             }
-            if (hookAdjustedField.meta) {
+            // Only create/update a database record if this is not a system field
+            if (hookAdjustedField.meta && !isSystemField(collection, hookAdjustedField.field)) {
                 if (record) {
                     await this.itemsService.updateOne(record.id, {
                         ...hookAdjustedField.meta,
@@ -463,11 +501,13 @@ export class FieldsService {
         const nestedActionEvents = [];
         try {
             const fieldNames = [];
+            const attemptConcurrentIndex = Boolean(opts?.attemptConcurrentIndex);
             for (const field of fields) {
                 fieldNames.push(await this.updateField(collection, field, {
                     autoPurgeCache: false,
                     autoPurgeSystemCache: false,
                     bypassEmitAction: (params) => nestedActionEvents.push(params),
+                    attemptConcurrentIndex,
                 }));
             }
             return fieldNames;
@@ -590,6 +630,22 @@ export class FieldsService {
                         field: { _eq: field },
                     },
                 }, { emitEvents: false });
+                // cleanup permissions for deleted field
+                const permissionRows = await trx
+                    .select('id', 'collection', 'fields')
+                    .from('directus_permissions')
+                    .whereRaw('?? = ? AND ?? LIKE ?', ['collection', collection, 'fields', '%' + field + '%']);
+                if (permissionRows.length > 0) {
+                    for (const permissionRow of permissionRows) {
+                        const newFields = permissionRow['fields']
+                            .split(',')
+                            .filter((v) => v !== field)
+                            .join(',');
+                        await trx('directus_permissions')
+                            .update('fields', newFields.length > 0 ? newFields : null)
+                            .where('id', '=', permissionRow['id']);
+                    }
+                }
             });
             const actionEvent = {
                 event: 'fields.delete',
@@ -629,11 +685,12 @@ export class FieldsService {
             }
         }
     }
-    addColumnToTable(table, collection, field, existing = null) {
+    addColumnToTable(table, collection, field, options) {
         let column;
         // Don't attempt to add a DB column for alias / corrupt fields
         if (field.type === 'alias' || field.type === 'unknown')
             return;
+        const existing = options?.existing ?? null;
         if (field.schema?.has_auto_increment) {
             if (field.type === 'bigInteger') {
                 column = table.bigIncrements(field.field);
@@ -707,28 +764,48 @@ export class FieldsService {
         else if (!existing?.is_primary_key) {
             // primary key will already have unique/index constraints
             if (field.schema?.is_unique === true) {
-                if (!existing || existing.is_unique === false) {
+                if ((!existing || existing.is_unique === false) && !options?.attemptConcurrentIndex) {
                     column.unique({ indexName: this.helpers.schema.generateIndexName('unique', collection, field.field) });
                 }
             }
-            else if (field.schema?.is_unique === false) {
-                if (existing?.is_unique === true) {
-                    table.dropUnique([field.field], this.helpers.schema.generateIndexName('unique', collection, field.field));
-                }
+            else if (field.schema?.is_unique === false && existing?.is_unique === true) {
+                table.dropUnique([field.field], this.helpers.schema.generateIndexName('unique', collection, field.field));
             }
             if (field.schema?.is_indexed === true) {
-                if (!existing || existing.is_indexed === false) {
+                if ((!existing || existing.is_indexed === false) && !options?.attemptConcurrentIndex) {
                     column.index(this.helpers.schema.generateIndexName('index', collection, field.field));
                 }
             }
-            else if (field.schema?.is_indexed === false) {
-                if (existing?.is_indexed === true) {
-                    table.dropIndex([field.field], this.helpers.schema.generateIndexName('index', collection, field.field));
-                }
+            else if (field.schema?.is_indexed === false && existing?.is_indexed === true) {
+                table.dropIndex([field.field], this.helpers.schema.generateIndexName('index', collection, field.field));
             }
         }
         if (existing) {
             column.alter();
         }
     }
+    async addColumnIndex(collection, field, options) {
+        const attemptConcurrentIndex = Boolean(options?.attemptConcurrentIndex);
+        const knex = options?.knex ?? this.knex;
+        const existing = options?.existing ?? null;
+        // Don't attempt to index a DB column for alias / corrupt fields
+        if (field.type === 'alias' || field.type === 'unknown')
+            return;
+        // primary key will already have unique/index constraints
+        if (field.schema?.is_primary_key || existing?.is_primary_key)
+            return;
+        const helpers = getHelpers(knex);
+        if (field.schema?.is_unique === true && (!existing || existing.is_unique == false)) {
+            await helpers.schema.createIndex(collection, field.field, {
+                unique: true,
+                attemptConcurrentIndex,
+            });
+        }
+        if (field.schema?.is_indexed === true && (!existing || existing.is_indexed === false)) {
+            await helpers.schema.createIndex(collection, field.field, {
+                unique: false,
+                attemptConcurrentIndex,
+            });
+        }
+    }
 }

package/dist/services/graphql/resolvers/query.js

@@ -19,8 +19,8 @@ export async function resolveQuery(gql, info) {
     let query;
     const isAggregate = collection.endsWith('_aggregated') && collection in gql.schema.collections === false;
     if (isAggregate) {
-        query = await getAggregateQuery(args, selections, gql.schema, gql.accountability);
         collection = collection.slice(0, -11);
+        query = await getAggregateQuery(args, selections, gql.schema, gql.accountability, collection);
     }
     else {
         query = await getQuery(args, gql.schema, selections, info.variableValues, gql.accountability, collection);

package/dist/services/graphql/resolvers/system-admin.js

@@ -1,13 +1,16 @@
+import { InvalidPayloadError } from '@directus/errors';
+import { isSystemField } from '@directus/system-data';
 import { GraphQLBoolean, GraphQLID, GraphQLList, GraphQLNonNull, GraphQLString } from 'graphql';
 import { SchemaComposer, toInputObjectType } from 'graphql-compose';
+import { fromZodError } from 'zod-validation-error';
 import { CollectionsService } from '../../collections.js';
 import { ExtensionsService } from '../../extensions.js';
-import { FieldsService } from '../../fields.js';
+import { FieldsService, systemFieldUpdateSchema } from '../../fields.js';
 import { RelationsService } from '../../relations.js';
 import { GraphQLService } from '../index.js';
+import { getCollectionType } from './get-collection-type.js';
 import { getFieldType } from './get-field-type.js';
 import { getRelationType } from './get-relation-type.js';
-import { getCollectionType } from './get-collection-type.js';
 export function resolveSystemAdmin(gql, schema, schemaComposer) {
     if (!gql.accountability?.admin) {
         return;
@@ -24,13 +27,16 @@ export function resolveSystemAdmin(gql, schema, schemaComposer) {
                 }).addFields({
                     fields: [toInputObjectType(Field, { postfix: '_input' }).NonNull],
                 }).NonNull,
+                concurrentIndexCreation: { type: GraphQLBoolean, defaultValue: false },
             },
             resolve: async (_, args) => {
                 const collectionsService = new CollectionsService({
                     accountability: gql.accountability,
                     schema: gql.schema,
                 });
-                const collectionKey = await collectionsService.createOne(args['data']);
+                const collectionKey = await collectionsService.createOne(args['data'], {
+                    attemptConcurrentIndex: Boolean(args['concurrentIndexCreation']),
+                });
                 return await collectionsService.readOne(collectionKey);
             },
         },
@@ -77,13 +83,16 @@ export function resolveSystemAdmin(gql, schema, schemaComposer) {
             args: {
                 collection: new GraphQLNonNull(GraphQLString),
                 data: toInputObjectType(Field, { postfix: '_input' }).NonNull,
+                concurrentIndexCreation: { type: GraphQLBoolean, defaultValue: false },
             },
             resolve: async (_, args) => {
                 const service = new FieldsService({
                     accountability: gql.accountability,
                     schema: gql.schema,
                 });
-                await service.createField(args['collection'], args['data']);
+                await service.createField(args['collection'], args['data'], undefined, {
+                    attemptConcurrentIndex: Boolean(args['concurrentIndexCreation']),
+                });
                 return await service.readOne(args['collection'], args['data'].field);
             },
         },
@@ -93,17 +102,52 @@ export function resolveSystemAdmin(gql, schema, schemaComposer) {
                 collection: new GraphQLNonNull(GraphQLString),
                 field: new GraphQLNonNull(GraphQLString),
                 data: toInputObjectType(Field, { postfix: '_input' }).NonNull,
+                concurrentIndexCreation: { type: GraphQLBoolean, defaultValue: false },
             },
             resolve: async (_, args) => {
                 const service = new FieldsService({
                     accountability: gql.accountability,
                     schema: gql.schema,
                 });
+                if (isSystemField(args['collection'], args['field'])) {
+                    const validationResult = systemFieldUpdateSchema.safeParse(args['data']);
+                    if (!validationResult.success) {
+                        throw new InvalidPayloadError({ reason: fromZodError(validationResult.error).message });
+                    }
+                }
                 await service.updateField(args['collection'], {
                     ...args['data'],
                     field: args['field'],
+                }, {
+                    attemptConcurrentIndex: Boolean(args['concurrentIndexCreation']),
                 });
-                return await service.readOne(args['collection'], args['data'].field);
+                return await service.readOne(args['collection'], args['field']);
+            },
+        },
+        update_fields_items: {
+            type: Field,
+            args: {
+                collection: new GraphQLNonNull(GraphQLString),
+                data: [toInputObjectType(Field, { postfix: '_input' }).NonNull],
+                concurrentIndexCreation: { type: GraphQLBoolean, defaultValue: false },
+            },
+            resolve: async (_, args) => {
+                const service = new FieldsService({
+                    accountability: gql.accountability,
+                    schema: gql.schema,
+                });
+                for (const fieldData of args['data']) {
+                    if (isSystemField(args['collection'], fieldData['field'])) {
+                        const validationResult = systemFieldUpdateSchema.safeParse(fieldData);
+                        if (!validationResult.success) {
+                            throw new InvalidPayloadError({ reason: fromZodError(validationResult.error).message });
+                        }
+                    }
+                }
+                await service.updateFields(args['collection'], args['data'], {
+                    attemptConcurrentIndex: Boolean(args['concurrentIndexCreation']),
+                });
+                return await service.readOne(args['collection'], args['field']);
             },
         },
         delete_fields_item: {

package/dist/services/graphql/schema/parse-query.js

@@ -1,9 +1,9 @@
 import { get, mapKeys, merge, set, uniq } from 'lodash-es';
 import { sanitizeQuery } from '../../../utils/sanitize-query.js';
 import { validateQuery } from '../../../utils/validate-query.js';
+import { filterReplaceM2A, filterReplaceM2ADeep } from '../utils/filter-replace-m2a.js';
 import { replaceFuncs } from '../utils/replace-funcs.js';
 import { parseArgs } from './parse-args.js';
-import { filterReplaceM2A, filterReplaceM2ADeep } from '../utils/filter-replace-m2a.js';
 /**
  * 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.
@@ -52,7 +52,8 @@ export async function getQuery(rawQuery, schema, selections, variableValues, acc
                         if (selection.selectionSet) {
                             if (!query.deep)
                                 query.deep = {};
-                            set(query.deep, parent, merge({}, get(query.deep, parent), { _alias: { [selection.alias.value]: selection.name.value } }));
+                            const path = parent.replaceAll(':', '__');
+                            set(query.deep, path, merge({}, get(query.deep, parent), { _alias: { [selection.alias.value]: selection.name.value } }));
                         }
                     }
                 }
@@ -79,12 +80,11 @@ export async function getQuery(rawQuery, schema, selections, variableValues, acc
                 fields.push(current);
             }
             if (selection.kind === 'Field' && selection.arguments && selection.arguments.length > 0) {
-                if (selection.arguments && selection.arguments.length > 0) {
-                    if (!query.deep)
-                        query.deep = {};
-                    const args = parseArgs(selection.arguments, variableValues);
-                    set(query.deep, currentAlias ?? current, merge({}, get(query.deep, currentAlias ?? current), mapKeys(await sanitizeQuery(args, schema, accountability), (_value, key) => `_${key}`)));
-                }
+                if (!query.deep)
+                    query.deep = {};
+                const args = parseArgs(selection.arguments, variableValues);
+                const path = (currentAlias ?? current).replaceAll(':', '__');
+                set(query.deep, path, merge({}, get(query.deep, path), mapKeys(await sanitizeQuery(args, schema, accountability), (_value, key) => `_${key}`)));
             }
         }
         return uniq(fields);

package/dist/services/graphql/utils/aggregate-query.d.ts

@@ -3,4 +3,4 @@ import type { SelectionNode } from 'graphql';
 /**
  * Resolve the aggregation query based on the requested aggregated fields
  */
-export declare function getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[], schema: SchemaOverview, accountability?: Accountability | null): Promise<Query>;
+export declare function getAggregateQuery(rawQuery: Query, selections: readonly SelectionNode[], schema: SchemaOverview, accountability?: Accountability | null, collection?: string): Promise<Query>;

package/dist/services/graphql/utils/aggregate-query.js

@@ -1,10 +1,11 @@
 import { sanitizeQuery } from '../../../utils/sanitize-query.js';
 import { validateQuery } from '../../../utils/validate-query.js';
+import { filterReplaceM2A } from './filter-replace-m2a.js';
 import { replaceFuncs } from './replace-funcs.js';
 /**
  * Resolve the aggregation query based on the requested aggregated fields
  */
-export async function getAggregateQuery(rawQuery, selections, schema, accountability) {
+export async function getAggregateQuery(rawQuery, selections, schema, accountability, collection) {
     const query = await sanitizeQuery(rawQuery, schema, accountability);
     query.aggregate = {};
     for (let aggregationGroup of selections) {
@@ -27,6 +28,9 @@ export async function getAggregateQuery(rawQuery, selections, schema, accountabi
     if (query.filter) {
         query.filter = replaceFuncs(query.filter);
     }
+    if (collection && query.filter) {
+        query.filter = filterReplaceM2A(query.filter, collection, schema);
+    }
     validateQuery(query);
     return query;
 }

package/dist/services/graphql/utils/filter-replace-m2a.js

@@ -48,7 +48,8 @@ export function filterReplaceM2ADeep(deep_arg, collection, schema) {
                 deep[key] = filterReplaceM2ADeep(deep[key], relation.related_collection, schema);
             }
             else if (type === 'a2o' && any_collection && relation.meta?.one_allowed_collections?.includes(any_collection)) {
-                deep[key] = filterReplaceM2ADeep(deep[key], any_collection, schema);
+                deep[`${field}:${any_collection}`] = filterReplaceM2ADeep(deep[key], any_collection, schema);
+                delete deep[key];
             }
         }
         if (key === '_filter') {

package/dist/services/import-export.d.ts

@@ -1,7 +1,15 @@
-import type { AbstractServiceOptions, Accountability, ExportFormat, File, Query, SchemaOverview } from '@directus/types';
+import type { AbstractServiceOptions, Accountability, DirectusError, ExportFormat, File, Query, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
 import type { Readable } from 'node:stream';
 import type { FunctionFieldNode, FieldNode, NestedCollectionNode } from '../types/index.js';
+export declare function createErrorTracker(): {
+    addCapturedError: (err: any, rowNumber: number) => void;
+    buildFinalErrors: () => DirectusError<any>[];
+    getCount: () => number;
+    hasErrors: () => boolean;
+    shouldStop: () => boolean;
+    hasGenericError: () => boolean;
+};
 export declare class ImportService {
     knex: Knex;
     accountability: Accountability | null;