@directus/api 11.1.0 → 12.0.1

package/dist/services/payload.js

@@ -7,7 +7,7 @@ import { v4 as uuid } from 'uuid';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { generateHash } from '../utils/generate-hash.js';
 import { ItemsService } from './items.js';
 /**
@@ -262,14 +262,14 @@ export class PayloadService {
                         if (dateColumn.type === 'date') {
                             const parsedDate = parseISO(value);
                             if (!isValid(parsedDate)) {
-                                throw new InvalidPayloadException(`Invalid Date format in field "${dateColumn.field}"`);
+                                throw new InvalidPayloadError({ reason: `Invalid Date format in field "${dateColumn.field}"` });
                             }
                             payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'dateTime') {
                             const parsedDate = parseISO(value);
                             if (!isValid(parsedDate)) {
-                                throw new InvalidPayloadException(`Invalid DateTime format in field "${dateColumn.field}"`);
+                                throw new InvalidPayloadError({ reason: `Invalid DateTime format in field "${dateColumn.field}"` });
                             }
                             payload[name] = parsedDate;
                         }
@@ -318,11 +318,15 @@ export class PayloadService {
                 continue;
             const relatedCollection = payload[relation.meta.one_collection_field];
             if (!relatedCollection) {
-                throw new InvalidPayloadException(`Can't update nested record "${relation.collection}.${relation.field}" without field "${relation.collection}.${relation.meta.one_collection_field}" being set`);
+                throw new InvalidPayloadError({
+                    reason: `Can't update nested record "${relation.collection}.${relation.field}" without field "${relation.collection}.${relation.meta.one_collection_field}" being set`,
+                });
             }
             const allowedCollections = relation.meta.one_allowed_collections;
             if (allowedCollections.includes(relatedCollection) === false) {
-                throw new InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`);
+                throw new InvalidPayloadError({
+                    reason: `"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`,
+                });
             }
             const itemsService = new ItemsService(relatedCollection, {
                 accountability: this.accountability,
@@ -474,7 +478,7 @@ export class PayloadService {
                             .where({ [relatedPrimaryKeyField]: record })
                             .first();
                         if (!!existingRecord === false) {
-                            throw new ForbiddenException();
+                            throw new ForbiddenError();
                         }
                         // If the related item is already associated to the current item, and there's no
                         // other updates (which is indicated by the fact that this is just the PK, we can
@@ -542,7 +546,7 @@ export class PayloadService {
                 const alterations = field;
                 const { error } = nestedUpdateSchema.validate(alterations);
                 if (error)
-                    throw new InvalidPayloadException(`Invalid one-to-many update structure: ${error.message}`);
+                    throw new InvalidPayloadError({ reason: `Invalid one-to-many update structure: ${error.message}` });
                 if (alterations.create) {
                     const sortField = relation.meta.sort_field;
                     let createPayload;

package/dist/services/relations.js

@@ -5,7 +5,7 @@ import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemRelationRows } from '../database/system-data/relations/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { ItemsService } from './items.js';
@@ -37,7 +37,7 @@ export class RelationsService {
     }
     async readAll(collection, opts) {
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const metaReadQuery = {
             limit: -1,
@@ -64,17 +64,17 @@ export class RelationsService {
     async readOne(collection, field) {
         if (this.accountability && this.accountability.admin !== true) {
             if (this.hasReadAccess === false) {
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             }
             const permissions = this.accountability.permissions?.find((permission) => {
                 return permission.action === 'read' && permission.collection === collection;
             });
             if (!permissions || !permissions.fields)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             if (permissions.fields.includes('*') === false) {
                 const allowedFields = permissions.fields;
                 if (allowedFields.includes(field) === false)
-                    throw new ForbiddenException();
+                    throw new ForbiddenError();
             }
         }
         const metaRow = await this.relationsItemService.readByQuery({
@@ -98,7 +98,7 @@ export class RelationsService {
         const stitched = this.stitchRelations(metaRow, schemaRow ? [schemaRow] : []);
         const results = await this.filterForbidden(stitched);
         if (results.length === 0) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         return results[0];
     }
@@ -107,30 +107,36 @@ export class RelationsService {
      */
     async createOne(relation, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (!relation.collection) {
-            throw new InvalidPayloadException('"collection" is required');
+            throw new InvalidPayloadError({ reason: '"collection" is required' });
         }
         if (!relation.field) {
-            throw new InvalidPayloadException('"field" is required');
+            throw new InvalidPayloadError({ reason: '"field" is required' });
         }
         if (relation.collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${relation.collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
         }
         if (relation.field in this.schema.collections[relation.collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${relation.field}" doesn't exist in collection "${relation.collection}"`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"`,
+            });
         }
         // A primary key should not be a foreign key
         if (this.schema.collections[relation.collection].primary === relation.field) {
-            throw new InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" is a primary key`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key`,
+            });
         }
         if (relation.related_collection && relation.related_collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${relation.related_collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${relation.related_collection}" doesn't exist` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === relation.collection && existingRelation.field === relation.field);
         if (existingRelation) {
-            throw new InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         this.helpers.schema.preRelationChange(relation);
@@ -190,17 +196,19 @@ export class RelationsService {
      */
     async updateOne(collection, field, relation, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
         if (field in this.schema.collections[collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${field}" doesn't exist in collection "${collection}"`);
+            throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
         if (!existingRelation) {
-            throw new InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
+            throw new InvalidPayloadError({
+                reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         this.helpers.schema.preRelationChange(relation);
@@ -273,17 +281,19 @@ export class RelationsService {
      */
     async deleteOne(collection, field, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
         if (field in this.schema.collections[collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${field}" doesn't exist in collection "${collection}"`);
+            throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
         if (!existingRelation) {
-            throw new InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
+            throw new InvalidPayloadError({
+                reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];

package/dist/services/revisions.js

@@ -1,4 +1,4 @@
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 export class RevisionsService extends ItemsService {
     constructor(options) {
@@ -7,9 +7,9 @@ export class RevisionsService extends ItemsService {
     async revert(pk) {
         const revision = await super.readOne(pk);
         if (!revision)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         if (!revision['data'])
-            throw new InvalidPayloadException(`Revision doesn't contain data to revert to`);
+            throw new InvalidPayloadError({ reason: `Revision doesn't contain data to revert to` });
         const service = new ItemsService(revision['collection'], {
             accountability: this.accountability,
             knex: this.knex,

package/dist/services/roles.js

@@ -1,4 +1,4 @@
-import { ForbiddenException, UnprocessableEntityException } from '../exceptions/index.js';
+import { ForbiddenError, UnprocessableContentError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions.js';
 import { PresetsService } from './presets.js';
@@ -16,13 +16,14 @@ export class RolesService extends ItemsService {
             .andWhere({ admin_access: true })
             .first();
         const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
-        if (otherAdminRolesCount === 0)
-            throw new UnprocessableEntityException(`You can't delete the last admin role.`);
+        if (otherAdminRolesCount === 0) {
+            throw new UnprocessableContentError({ reason: `You can't delete the last admin role` });
+        }
     }
     async checkForOtherAdminUsers(key, users) {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
         if (!role)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         // The users that will now be in this new non-admin role
         let userKeys = [];
         if (Array.isArray(users)) {
@@ -48,7 +49,7 @@ export class RolesService extends ItemsService {
             .first();
         const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
         if (otherAdminUsersCount === 0) {
-            throw new UnprocessableEntityException(`You can't remove the last admin user from the admin role.`);
+            throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
         }
         return;
     }
@@ -59,7 +60,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateOne(key, data, opts);
     }
@@ -73,7 +74,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateBatch(data, opts);
     }
@@ -84,7 +85,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateMany(keys, data, opts);
     }
@@ -98,7 +99,7 @@ export class RolesService extends ItemsService {
             await this.checkForOtherAdminRoles(keys);
         }
         catch (err) {
-            opts.preMutationException = err;
+            opts.preMutationError = err;
         }
         await this.knex.transaction(async (trx) => {
             const itemsService = new ItemsService('directus_roles', {

package/dist/services/schema.js

@@ -1,8 +1,8 @@
 import getDatabase from '../database/index.js';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/index.js';
 import { applyDiff } from '../utils/apply-diff.js';
-import { getSnapshot } from '../utils/get-snapshot.js';
 import { getSnapshotDiff } from '../utils/get-snapshot-diff.js';
+import { getSnapshot } from '../utils/get-snapshot.js';
 import { getVersionedHash } from '../utils/get-versioned-hash.js';
 import { validateApplyDiff } from '../utils/validate-diff.js';
 import { validateSnapshot } from '../utils/validate-snapshot.js';
@@ -15,13 +15,13 @@ export class SchemaService {
     }
     async snapshot() {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const currentSnapshot = await getSnapshot({ database: this.knex });
         return currentSnapshot;
     }
     async apply(payload) {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const currentSnapshot = await this.snapshot();
         const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
         if (!validateApplyDiff(payload, snapshotWithHash))
@@ -30,7 +30,7 @@ export class SchemaService {
     }
     async diff(snapshot, options) {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         validateSnapshot(snapshot, options?.force);
         const currentSnapshot = options?.currentSnapshot ?? (await getSnapshot({ database: this.knex }));
         const diff = getSnapshotDiff(currentSnapshot, snapshot);

package/dist/services/shares.js

@@ -1,7 +1,7 @@
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
 import env from '../env.js';
-import { ForbiddenException, InvalidCredentialsException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidCredentialsError } from '../errors/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
@@ -51,10 +51,10 @@ export class SharesService extends ItemsService {
         })
             .first();
         if (!record) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         if (record.share_password && !(await argon2.verify(record.share_password, payload['password']))) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         await this.knex('directus_shares')
             .update({ times_used: record.share_times_used + 1 })
@@ -96,7 +96,7 @@ export class SharesService extends ItemsService {
      */
     async invite(payload) {
         if (!this.accountability?.user)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const share = await this.readOne(payload.share, { fields: ['collection'] });
         const usersService = new UsersService({
             knex: this.knex,

package/dist/services/tfa.js

@@ -1,6 +1,6 @@
 import { authenticator } from 'otplib';
 import getDatabase from '../database/index.js';
-import { InvalidPayloadException } from '../exceptions/index.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 export class TFAService {
     knex;
@@ -15,17 +15,17 @@ export class TFAService {
         }
         const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
         if (!user?.tfa_secret) {
-            throw new InvalidPayloadException(`User "${key}" doesn't have TFA enabled.`);
+            throw new InvalidPayloadError({ reason: `User "${key}" doesn't have TFA enabled` });
         }
         return authenticator.check(otp, user.tfa_secret);
     }
     async generateTFA(key) {
         const user = await this.knex.select('email', 'tfa_secret').from('directus_users').where({ id: key }).first();
         if (user?.tfa_secret !== null) {
-            throw new InvalidPayloadException('TFA Secret is already set for this user');
+            throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
         if (!user?.email) {
-            throw new InvalidPayloadException('User must have a valid email to enable TFA');
+            throw new InvalidPayloadError({ reason: 'User must have a valid email to enable TFA' });
         }
         const secret = authenticator.generateSecret();
         const project = await this.knex.select('project_name').from('directus_settings').limit(1).first();
@@ -37,10 +37,10 @@ export class TFAService {
     async enableTFA(key, otp, secret) {
         const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
         if (user?.tfa_secret !== null) {
-            throw new InvalidPayloadException('TFA Secret is already set for this user');
+            throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
         if (!authenticator.check(otp, secret)) {
-            throw new InvalidPayloadException(`"otp" is invalid`);
+            throw new InvalidPayloadError({ reason: `"otp" is invalid` });
         }
         await this.itemsService.updateOne(key, { tfa_secret: secret });
     }

package/dist/services/translations.d.ts

@@ -1,7 +1,7 @@
 import type { Item, PrimaryKey } from '@directus/types';
-import { ItemsService } from './items.js';
-import type { AbstractServiceOptions } from '../types/services.js';
 import type { MutationOptions } from '../types/items.js';
+import type { AbstractServiceOptions } from '../types/services.js';
+import { ItemsService } from './items.js';
 export declare class TranslationsService extends ItemsService {
     constructor(options: AbstractServiceOptions);
     private translationKeyExists;

package/dist/services/translations.js

@@ -1,6 +1,6 @@
 import getDatabase from '../database/index.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
-import { InvalidPayloadException } from '../index.js';
 export class TranslationsService extends ItemsService {
     constructor(options) {
         super('directus_translations', options);
@@ -14,20 +14,20 @@ export class TranslationsService extends ItemsService {
     }
     async createOne(data, opts) {
         if (await this.translationKeyExists(data['key'], data['language'])) {
-            throw new InvalidPayloadException('Duplicate key and language combination.');
+            throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
         }
         return await super.createOne(data, opts);
     }
     async updateMany(keys, data, opts) {
         if (keys.length > 0 && 'key' in data && 'language' in data) {
-            throw new InvalidPayloadException('Duplicate key and language combination.');
+            throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
         }
         else if ('key' in data || 'language' in data) {
             const items = await this.readMany(keys);
             for (const item of items) {
                 const updatedData = { ...item, ...data };
                 if (await this.translationKeyExists(updatedData['key'], updatedData['language'])) {
-                    throw new InvalidPayloadException('Duplicate key and language combination.');
+                    throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
                 }
             }
         }

package/dist/services/users.js

@@ -1,12 +1,12 @@
-import { FailedValidationException } from '@directus/exceptions';
 import { getSimpleHash, toArray } from '@directus/utils';
+import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import jwt from 'jsonwebtoken';
 import { cloneDeep, isEmpty } from 'lodash-es';
 import { performance } from 'perf_hooks';
 import getDatabase from '../database/index.js';
 import env from '../env.js';
-import { RecordNotUniqueException } from '../exceptions/database/record-not-unique.js';
-import { ForbiddenException, InvalidPayloadException, UnprocessableEntityException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/forbidden.js';
+import { InvalidPayloadError, RecordNotUniqueError, UnprocessableContentError } from '../errors/index.js';
 import isUrlAllowed from '../utils/is-url-allowed.js';
 import { verifyJWT } from '../utils/jwt.js';
 import { stall } from '../utils/stall.js';
@@ -29,10 +29,9 @@ export class UsersService extends ItemsService {
         emails = emails.map((email) => email.toLowerCase());
         const duplicates = emails.filter((value, index, array) => array.indexOf(value) !== index);
         if (duplicates.length) {
-            throw new RecordNotUniqueException('email', {
+            throw new RecordNotUniqueError({
                 collection: 'directus_users',
                 field: 'email',
-                invalid: duplicates[0],
             });
         }
         const query = this.knex
@@ -44,10 +43,9 @@ export class UsersService extends ItemsService {
         }
         const results = await query;
         if (results.length) {
-            throw new RecordNotUniqueException('email', {
+            throw new RecordNotUniqueError({
                 collection: 'directus_users',
                 field: 'email',
-                invalid: results[0].email,
             });
         }
     }
@@ -70,14 +68,14 @@ export class UsersService extends ItemsService {
         const regex = new RegExp(wrapped ? policyRegExString.slice(1, -1) : policyRegExString);
         for (const password of passwords) {
             if (!regex.test(password)) {
-                throw new FailedValidationException({
+                throw new FailedValidationError(joiValidationErrorItemToErrorExtensions({
                     message: `Provided password doesn't match password policy`,
                     path: ['password'],
                     type: 'custom.pattern.base',
                     context: {
                         value: password,
                     },
-                });
+                }));
             }
         }
     }
@@ -92,7 +90,7 @@ export class UsersService extends ItemsService {
             .first();
         const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
         if (otherAdminUsersCount === 0) {
-            throw new UnprocessableEntityException(`You can't remove the last admin user from the role.`);
+            throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the role` });
         }
     }
     /**
@@ -109,7 +107,7 @@ export class UsersService extends ItemsService {
             .first();
         const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
         if (otherAdminUsersCount === 0) {
-            throw new UnprocessableEntityException(`You can't change the active status of the last admin user.`);
+            throw new UnprocessableContentError({ reason: `You can't change the active status of the last admin user` });
         }
     }
     /**
@@ -154,7 +152,7 @@ export class UsersService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return await super.createMany(data, opts);
     }
@@ -185,7 +183,7 @@ export class UsersService extends ItemsService {
             });
             for (const item of data) {
                 if (!item[primaryKeyField])
-                    throw new InvalidPayloadException(`User in update misses primary key.`);
+                    throw new InvalidPayloadError({ reason: `User in update misses primary key` });
                 keys.push(await service.updateOne(item[primaryKeyField], item, opts));
             }
         });
@@ -209,10 +207,9 @@ export class UsersService extends ItemsService {
             }
             if (data['email']) {
                 if (keys.length > 1) {
-                    throw new RecordNotUniqueException('email', {
+                    throw new RecordNotUniqueError({
                         collection: 'directus_users',
                         field: 'email',
-                        invalid: data['email'],
                     });
                 }
                 await this.checkUniqueEmails([data['email']], keys[0]);
@@ -221,23 +218,23 @@ export class UsersService extends ItemsService {
                 await this.checkPasswordPolicy([data['password']]);
             }
             if (data['tfa_secret'] !== undefined) {
-                throw new InvalidPayloadException(`You can't change the "tfa_secret" value manually.`);
+                throw new InvalidPayloadError({ reason: `You can't change the "tfa_secret" value manually` });
             }
             if (data['provider'] !== undefined) {
                 if (this.accountability && this.accountability.admin !== true) {
-                    throw new InvalidPayloadException(`You can't change the "provider" value manually.`);
+                    throw new InvalidPayloadError({ reason: `You can't change the "provider" value manually` });
                 }
                 data['auth_data'] = null;
             }
             if (data['external_identifier'] !== undefined) {
                 if (this.accountability && this.accountability.admin !== true) {
-                    throw new InvalidPayloadException(`You can't change the "external_identifier" value manually.`);
+                    throw new InvalidPayloadError({ reason: `You can't change the "external_identifier" value manually` });
                 }
                 data['auth_data'] = null;
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return await super.updateMany(keys, data, opts);
     }
@@ -256,7 +253,7 @@ export class UsersService extends ItemsService {
             await this.checkRemainingAdminExistence(keys);
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         await this.knex('directus_notifications').update({ sender: null }).whereIn('sender', keys);
         await super.deleteMany(keys, opts);
@@ -281,11 +278,11 @@ export class UsersService extends ItemsService {
         const opts = {};
         try {
             if (url && isUrlAllowed(url, env['USER_INVITE_URL_ALLOW_LIST']) === false) {
-                throw new InvalidPayloadException(`Url "${url}" can't be used to invite users.`);
+                throw new InvalidPayloadError({ reason: `Url "${url}" can't be used to invite users` });
             }
         }
         catch (err) {
-            opts.preMutationException = err;
+            opts.preMutationError = err;
         }
         const emails = toArray(email);
         const mailService = new MailService({
@@ -323,10 +320,10 @@ export class UsersService extends ItemsService {
     async acceptInvite(token, password) {
         const { email, scope } = verifyJWT(token, env['SECRET']);
         if (scope !== 'invite')
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const user = await this.getUserByEmail(email);
         if (user?.status !== 'invited') {
-            throw new InvalidPayloadException(`Email address ${email} hasn't been invited.`);
+            throw new InvalidPayloadError({ reason: `Email address ${email} hasn't been invited` });
         }
         // Allow unauthenticated update
         const service = new UsersService({
@@ -341,10 +338,10 @@ export class UsersService extends ItemsService {
         const user = await this.getUserByEmail(email);
         if (user?.status !== 'active') {
             await stall(STALL_TIME, timeStart);
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (url && isUrlAllowed(url, env['PASSWORD_RESET_URL_ALLOW_LIST']) === false) {
-            throw new InvalidPayloadException(`Url "${url}" can't be used to reset passwords.`);
+            throw new InvalidPayloadError({ reason: `Url "${url}" can't be used to reset passwords` });
         }
         const mailService = new MailService({
             schema: this.schema,
@@ -373,17 +370,17 @@ export class UsersService extends ItemsService {
     async resetPassword(token, password) {
         const { email, scope, hash } = jwt.verify(token, env['SECRET'], { issuer: 'directus' });
         if (scope !== 'password-reset' || !hash)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const opts = {};
         try {
             await this.checkPasswordPolicy([password]);
         }
         catch (err) {
-            opts.preMutationException = err;
+            opts.preMutationError = err;
         }
         const user = await this.getUserByEmail(email);
         if (user?.status !== 'active' || hash !== getSimpleHash('' + user.password)) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         // Allow unauthenticated update
         const service = new UsersService({