@directus/api 30.0.0 → 32.0.0

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;

package/dist/services/import-export.js

@@ -1,5 +1,5 @@
 import { useEnv } from '@directus/env';
-import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
+import { createError, ErrorCode, ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '@directus/errors';
 import { isSystemCollection } from '@directus/system-data';
 import { parseJSON, toArray } from '@directus/utils';
 import { createTmpFile } from '@directus/utils/node';
@@ -28,6 +28,126 @@ import { parseFields } from '../database/get-ast-from-query/lib/parse-fields.js'
 import { set } from 'lodash-es';
 const env = useEnv();
 const logger = useLogger();
+const MAX_IMPORT_ERRORS = env['MAX_IMPORT_ERRORS'];
+export function createErrorTracker() {
+    let genericError;
+    // For errors with field / type (joi validation or DB with field)
+    const fieldErrors = new Map();
+    let capturedErrorCount = 0;
+    let isLimitReached = false;
+    function convertToRanges(rows, minRangeSize = 4) {
+        const sorted = Array.from(new Set(rows)).sort((a, b) => a - b);
+        const result = [];
+        if (sorted.length === 0)
+            return [];
+        let start = sorted[0];
+        let prev = sorted[0];
+        let count = 1;
+        const nonConsecutive = [];
+        const flush = () => {
+            if (count >= minRangeSize) {
+                result.push({ type: 'range', start, end: prev });
+            }
+            else {
+                for (let i = start; i <= prev; i++) {
+                    nonConsecutive.push(i);
+                }
+            }
+        };
+        for (let i = 1; i < sorted.length; i++) {
+            const current = sorted[i];
+            if (current === prev + 1) {
+                prev = current;
+                count++;
+            }
+            else {
+                flush();
+                start = prev = current;
+                count = 1;
+            }
+        }
+        flush();
+        // Add non-consecutive rows as a single "lines" entry
+        if (nonConsecutive.length > 0) {
+            result.push({ type: 'lines', rows: nonConsecutive });
+        }
+        return result;
+    }
+    function addCapturedError(err, rowNumber) {
+        const field = err.extensions?.field;
+        if (field) {
+            const type = err.extensions?.type;
+            const substring = err.extensions?.substring;
+            const valid = err.extensions?.valid;
+            const invalid = err.extensions?.invalid;
+            let key = type ? `${field}|${type}` : field;
+            if (substring !== undefined)
+                key += `|substring:${substring}`;
+            if (valid !== undefined)
+                key += `|valid:${JSON.stringify(valid)}`;
+            if (invalid !== undefined)
+                key += `|invalid:${JSON.stringify(invalid)}`;
+            if (!fieldErrors.has(err.code)) {
+                fieldErrors.set(err.code, new Map());
+            }
+            const errorsByCode = fieldErrors.get(err.code);
+            if (!errorsByCode.has(key)) {
+                errorsByCode.set(key, {
+                    message: err.message,
+                    rowNumbers: [],
+                });
+            }
+            errorsByCode.get(key).rowNumbers.push(rowNumber);
+        }
+        else {
+            genericError = err;
+        }
+        capturedErrorCount++;
+        if (capturedErrorCount >= MAX_IMPORT_ERRORS) {
+            isLimitReached = true;
+        }
+    }
+    function hasGenericError() {
+        return genericError !== undefined;
+    }
+    function buildFinalErrors() {
+        if (genericError) {
+            return [genericError];
+        }
+        return Array.from(fieldErrors.entries()).flatMap(([code, fieldMap]) => Array.from(fieldMap.entries()).map(([compositeKey, errorData]) => {
+            const parts = compositeKey.split('|');
+            const field = parts[0];
+            const type = parts[1];
+            const extensions = {};
+            for (let i = 2; i < parts.length; i++) {
+                const [paramType, paramValue] = parts[i]?.split(':', 2) ?? [];
+                if (!paramType || paramValue === undefined)
+                    continue;
+                try {
+                    extensions[paramType] = JSON.parse(paramValue);
+                }
+                catch {
+                    extensions[paramType] = paramValue;
+                }
+            }
+            const ErrorClass = createError(code, errorData.message, 400);
+            return new ErrorClass({
+                field,
+                type,
+                ...extensions,
+                rows: convertToRanges(errorData.rowNumbers),
+            });
+        }));
+    }
+    return {
+        addCapturedError,
+        buildFinalErrors,
+        getCount: () => capturedErrorCount,
+        hasErrors: () => capturedErrorCount > 0 || hasGenericError(),
+        shouldStop: () => isLimitReached || hasGenericError(),
+        hasGenericError,
+    };
+}
 export class ImportService {
     knex;
     accountability;
@@ -71,37 +191,72 @@ export class ImportService {
     async importJSON(collection, stream) {
         const extractJSON = StreamArray.withParser();
         const nestedActionEvents = [];
-        return transaction(this.knex, (trx) => {
+        const errorTracker = createErrorTracker();
+        return transaction(this.knex, async (trx) => {
             const service = getService(collection, {
                 knex: trx,
                 schema: this.schema,
                 accountability: this.accountability,
             });
-            const saveQueue = queue(async (value) => {
-                return await service.upsertOne(value, { bypassEmitAction: (params) => nestedActionEvents.push(params) });
-            });
-            return new Promise((resolve, reject) => {
-                stream.pipe(extractJSON);
-                extractJSON.on('data', ({ value }) => {
-                    saveQueue.push(value);
-                });
-                extractJSON.on('error', (err) => {
-                    destroyStream(stream);
-                    destroyStream(extractJSON);
-                    reject(new InvalidPayloadError({ reason: err.message }));
-                });
-                saveQueue.error((err) => {
-                    reject(err);
-                });
-                extractJSON.on('end', () => {
-                    saveQueue.drain(() => {
-                        for (const nestedActionEvent of nestedActionEvents) {
-                            emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+            try {
+                await new Promise((resolve, reject) => {
+                    let rowNumber = 1;
+                    const saveQueue = queue(async (task) => {
+                        if (errorTracker.shouldStop())
+                            return;
+                        try {
+                            const result = await service.upsertOne(task.data, {
+                                bypassEmitAction: (params) => nestedActionEvents.push(params),
+                            });
+                            return result;
+                        }
+                        catch (error) {
+                            for (const err of toArray(error)) {
+                                errorTracker.addCapturedError(err, task.rowNumber);
+                                if (errorTracker.shouldStop()) {
+                                    break;
+                                }
+                            }
+                            if (errorTracker.shouldStop()) {
+                                saveQueue.kill();
+                                destroyStream(stream);
+                                destroyStream(extractJSON);
+                                reject();
+                            }
+                            return;
                         }
-                        return resolve();
+                    });
+                    stream.pipe(extractJSON);
+                    extractJSON.on('data', ({ value }) => {
+                        saveQueue.push({ data: value, rowNumber: rowNumber++ });
+                    });
+                    extractJSON.on('error', (err) => {
+                        destroyStream(stream);
+                        destroyStream(extractJSON);
+                        reject(new InvalidPayloadError({ reason: err.message }));
+                    });
+                    extractJSON.on('end', () => {
+                        // In case of empty JSON file
+                        if (!saveQueue.started)
+                            return resolve();
+                        saveQueue.drain(() => {
+                            if (errorTracker.hasErrors()) {
+                                return reject();
+                            }
+                            for (const nestedActionEvent of nestedActionEvents) {
+                                emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                            }
+                            return resolve();
+                        });
                     });
                 });
-            });
+            }
+            catch (error) {
+                if (!error && errorTracker.hasErrors()) {
+                    throw errorTracker.buildFinalErrors();
+                }
+                throw error;
+            }
         });
     }
     async importCSV(collection, stream) {
@@ -109,98 +264,129 @@ export class ImportService {
         if (!tmpFile)
             throw new Error('Failed to create temporary file for import');
         const nestedActionEvents = [];
-        return transaction(this.knex, (trx) => {
+        const errorTracker = createErrorTracker();
+        return transaction(this.knex, async (trx) => {
             const service = getService(collection, {
                 knex: trx,
                 schema: this.schema,
                 accountability: this.accountability,
             });
-            const saveQueue = queue(async (value) => {
-                return await service.upsertOne(value, { bypassEmitAction: (action) => nestedActionEvents.push(action) });
-            });
-            const transform = (value) => {
-                if (value.length === 0)
-                    return;
-                try {
-                    const parsedJson = parseJSON(value);
-                    if (typeof parsedJson === 'number') {
-                        return value;
-                    }
-                    return parsedJson;
-                }
-                catch {
-                    return value;
-                }
-            };
-            const PapaOptions = {
-                header: true,
-                // Trim whitespaces in headers, including the byte order mark (BOM) zero-width no-break space
-                transformHeader: (header) => header.trim(),
-                transform,
-            };
-            return new Promise((resolve, reject) => {
-                const streams = [stream];
-                const cleanup = (destroy = true) => {
-                    if (destroy) {
-                        for (const stream of streams) {
-                            destroyStream(stream);
+            try {
+                await new Promise((resolve, reject) => {
+                    const streams = [stream];
+                    let rowNumber = 0;
+                    const cleanup = (destroy = true) => {
+                        if (destroy) {
+                            for (const stream of streams) {
+                                destroyStream(stream);
+                            }
                         }
-                    }
-                    tmpFile.cleanup().catch(() => {
-                        logger.warn(`Failed to cleanup temporary import file (${tmpFile.path})`);
-                    });
-                };
-                saveQueue.error((error) => {
-                    reject(error);
-                });
-                const fileWriteStream = createWriteStream(tmpFile.path)
-                    .on('error', (error) => {
-                    cleanup();
-                    reject(new Error('Error while writing import data to temporary file', { cause: error }));
-                })
-                    .on('finish', () => {
-                    const fileReadStream = createReadStream(tmpFile.path).on('error', (error) => {
-                        cleanup();
-                        reject(new Error('Error while reading import data from temporary file', { cause: error }));
-                    });
-                    streams.push(fileReadStream);
-                    fileReadStream
-                        .pipe(Papa.parse(Papa.NODE_STREAM_INPUT, PapaOptions))
-                        .on('data', (obj) => {
-                        const result = {};
-                        // Filter out all undefined fields
-                        for (const field in obj) {
-                            if (obj[field] !== undefined) {
-                                set(result, field, obj[field]);
+                        tmpFile.cleanup().catch(() => {
+                            logger.warn(`Failed to cleanup temporary import file (${tmpFile.path})`);
+                        });
+                    };
+                    const saveQueue = queue(async (task) => {
+                        if (errorTracker.shouldStop())
+                            return;
+                        try {
+                            const result = await service.upsertOne(task.data, {
+                                bypassEmitAction: (action) => nestedActionEvents.push(action),
+                            });
+                            return result;
+                        }
+                        catch (error) {
+                            for (const err of toArray(error)) {
+                                errorTracker.addCapturedError(err, task.rowNumber);
+                                if (errorTracker.shouldStop()) {
+                                    break;
+                                }
+                            }
+                            if (errorTracker.shouldStop()) {
+                                saveQueue.kill();
+                                cleanup(true);
+                                reject();
                             }
+                            return;
                         }
-                        saveQueue.push(result);
-                    })
+                    });
+                    const fileWriteStream = createWriteStream(tmpFile.path)
                         .on('error', (error) => {
                         cleanup();
-                        reject(new InvalidPayloadError({ reason: error.message }));
+                        reject(new Error('Error while writing import data to temporary file', { cause: error }));
                     })
-                        .on('end', () => {
-                        cleanup(false);
-                        // In case of empty CSV file
-                        if (!saveQueue.started)
-                            return resolve();
-                        saveQueue.drain(() => {
-                            for (const nestedActionEvent of nestedActionEvents) {
-                                emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                        .on('finish', () => {
+                        const fileReadStream = createReadStream(tmpFile.path).on('error', (error) => {
+                            cleanup();
+                            reject(new Error('Error while reading import data from temporary file', { cause: error }));
+                        });
+                        streams.push(fileReadStream);
+                        fileReadStream
+                            .pipe(Papa.parse(Papa.NODE_STREAM_INPUT, {
+                            header: true,
+                            transformHeader: (header) => header.trim(),
+                            transform: (value) => {
+                                if (value.length === 0)
+                                    return;
+                                try {
+                                    const parsedJson = parseJSON(value);
+                                    if (typeof parsedJson === 'number') {
+                                        return value;
+                                    }
+                                    return parsedJson;
+                                }
+                                catch {
+                                    return value;
+                                }
+                            },
+                        }))
+                            .on('data', (obj) => {
+                            rowNumber++;
+                            const result = {};
+                            for (const field in obj) {
+                                if (obj[field] !== undefined) {
+                                    set(result, field, obj[field]);
+                                }
                             }
-                            return resolve();
+                            saveQueue.push({ data: result, rowNumber });
+                        })
+                            .on('error', (error) => {
+                            cleanup();
+                            reject(new InvalidPayloadError({ reason: error.message }));
+                        })
+                            .on('end', () => {
+                            // In case of empty CSV file
+                            if (!saveQueue.started) {
+                                cleanup(false);
+                                return resolve();
+                            }
+                            saveQueue.drain(() => {
+                                if (!errorTracker.shouldStop())
+                                    cleanup(false);
+                                if (errorTracker.hasErrors()) {
+                                    return reject();
+                                }
+                                for (const nestedActionEvent of nestedActionEvents) {
+                                    emitter.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+                                }
+                                return resolve();
+                            });
                         });
                     });
+                    streams.push(fileWriteStream);
+                    stream
+                        .on('error', (error) => {
+                        cleanup();
+                        reject(new Error('Error while retrieving import data', { cause: error }));
+                    })
+                        .pipe(fileWriteStream);
                 });
-                streams.push(fileWriteStream);
-                stream
-                    .on('error', (error) => {
-                    cleanup();
-                    reject(new Error('Error while retrieving import data', { cause: error }));
-                })
-                    .pipe(fileWriteStream);
-            });
+            }
+            catch (error) {
+                if (!error && errorTracker.hasErrors()) {
+                    throw errorTracker.buildFinalErrors();
+                }
+                throw error;
+            }
         });
     }
 }

package/dist/services/items.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractService, AbstractServiceOptions, Accountability, Item as AnyItem, MutationTracker, MutationOptions, PrimaryKey, Query, QueryOptions, SchemaOverview } from '@directus/types';
+import type { AbstractService, AbstractServiceOptions, Accountability, Item as AnyItem, MutationOptions, MutationTracker, PrimaryKey, Query, QueryOptions, SchemaOverview } from '@directus/types';
 import type Keyv from 'keyv';
 import type { Knex } from 'knex';
 export declare class ItemsService<Item extends AnyItem = AnyItem, Collection extends string = string> implements AbstractService<Item> {