@directus/api 11.1.0 → 12.0.0

package/dist/middleware/rate-limiter-global.js

@@ -1,6 +1,5 @@
-import ms from 'ms';
 import env from '../env.js';
-import { HitRateLimitException } from '../exceptions/index.js';
+import { HitRateLimitError } from '../errors/index.js';
 import logger from '../logger.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
@@ -20,7 +19,7 @@ if (env['RATE_LIMITER_GLOBAL_ENABLED'] === true) {
             if (rateLimiterRes instanceof Error)
                 throw rateLimiterRes;
             res.set('Retry-After', String(Math.round(rateLimiterRes.msBeforeNext / 1000)));
-            throw new HitRateLimitException(`Too many requests, retry after ${ms(rateLimiterRes.msBeforeNext)}.`, {
+            throw new HitRateLimitError({
                 limit: +env['RATE_LIMITER_GLOBAL_POINTS'],
                 reset: new Date(Date.now() + rateLimiterRes.msBeforeNext),
             });

package/dist/middleware/rate-limiter-ip.d.ts

@@ -1,5 +1,5 @@
 import type { RequestHandler } from 'express';
-import type { RateLimiterMemcache, RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';
+import type { RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';
 declare let checkRateLimit: RequestHandler;
-export declare let rateLimiter: RateLimiterRedis | RateLimiterMemcache | RateLimiterMemory;
+export declare let rateLimiter: RateLimiterRedis | RateLimiterMemory;
 export default checkRateLimit;

package/dist/middleware/rate-limiter-ip.js

@@ -1,6 +1,5 @@
-import ms from 'ms';
 import env from '../env.js';
-import { HitRateLimitException } from '../exceptions/index.js';
+import { HitRateLimitError } from '../errors/index.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
@@ -18,7 +17,7 @@ if (env['RATE_LIMITER_ENABLED'] === true) {
             if (rateLimiterRes instanceof Error)
                 throw rateLimiterRes;
             res.set('Retry-After', String(Math.round(rateLimiterRes.msBeforeNext / 1000)));
-            throw new HitRateLimitException(`Too many requests, retry after ${ms(rateLimiterRes.msBeforeNext)}.`, {
+            throw new HitRateLimitError({
                 limit: +env['RATE_LIMITER_POINTS'],
                 reset: new Date(Date.now() + rateLimiterRes.msBeforeNext),
             });

package/dist/middleware/validate-batch.js

@@ -1,6 +1,5 @@
-import { FailedValidationException } from '@directus/exceptions';
 import Joi from 'joi';
-import { InvalidPayloadException } from '../exceptions/index.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import asyncHandler from '../utils/async-handler.js';
 import { sanitizeQuery } from '../utils/sanitize-query.js';
 export const validateBatch = (scope) => asyncHandler(async (req, _res, next) => {
@@ -12,7 +11,7 @@ export const validateBatch = (scope) => asyncHandler(async (req, _res, next) =>
         return next();
     }
     if (!req.body)
-        throw new InvalidPayloadException('Payload in body is required');
+        throw new InvalidPayloadError({ reason: 'Payload in body is required' });
     if (['update', 'delete'].includes(scope) && Array.isArray(req.body)) {
         return next();
     }
@@ -36,7 +35,7 @@ export const validateBatch = (scope) => asyncHandler(async (req, _res, next) =>
     }
     const { error } = batchSchema.validate(req.body);
     if (error) {
-        throw new FailedValidationException(error.details[0]);
+        throw new InvalidPayloadError({ reason: error.details[0].message });
     }
     return next();
 });

package/dist/rate-limiter.js

@@ -1,5 +1,5 @@
 import { merge } from 'lodash-es';
-import { RateLimiterMemcache, RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';
+import { RateLimiterMemory, RateLimiterRedis } from 'rate-limiter-flexible';
 import env from './env.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 import { createRequire } from 'node:module';
@@ -8,8 +8,6 @@ export function createRateLimiter(configPrefix = 'RATE_LIMITER', configOverrides
     switch (env['RATE_LIMITER_STORE']) {
         case 'redis':
             return new RateLimiterRedis(getConfig('redis', configPrefix, configOverrides));
-        case 'memcache':
-            return new RateLimiterMemcache(getConfig('memcache', configPrefix, configOverrides));
         case 'memory':
         default:
             return new RateLimiterMemory(getConfig('memory', configPrefix, configOverrides));
@@ -19,12 +17,7 @@ function getConfig(store = 'memory', configPrefix = 'RATE_LIMITER', overrides) {
     const config = getConfigFromEnv(`${configPrefix}_`, `${configPrefix}_${store}_`);
     if (store === 'redis') {
         const Redis = require('ioredis');
-        delete config.redis;
-        config.storeClient = new Redis(env[`${configPrefix}_REDIS`] || getConfigFromEnv(`${configPrefix}_REDIS_`));
-    }
-    if (store === 'memcache') {
-        const Memcached = require('memcached');
-        config.storeClient = new Memcached(env[`${configPrefix}_MEMCACHE`], getConfigFromEnv(`${configPrefix}_MEMCACHE_`));
+        config.storeClient = new Redis(env[`REDIS`] || getConfigFromEnv(`REDIS_`));
     }
     delete config.enabled;
     delete config.store;

package/dist/services/activity.js

@@ -1,8 +1,9 @@
 import { Action } from '@directus/constants';
+import { isDirectusError } from '@directus/errors';
 import { uniq } from 'lodash-es';
 import validateUUID from 'uuid-validate';
 import env from '../env.js';
-import { ForbiddenException } from '../exceptions/forbidden.js';
+import { ErrorCode } from '../errors/index.js';
 import logger from '../logger.js';
 import { getPermissions } from '../utils/get-permissions.js';
 import { Url } from '../utils/url.js';
@@ -80,7 +81,7 @@ ${comment}
                     });
                 }
                 catch (err) {
-                    if (err instanceof ForbiddenException) {
+                    if (isDirectusError(err, ErrorCode.Forbidden)) {
                         logger.warn(`User ${userID} doesn't have proper permissions to receive notification for this item.`);
                     }
                     else {

package/dist/services/assets.js

@@ -7,10 +7,7 @@ import validateUUID from 'uuid-validate';
 import { SUPPORTED_IMAGE_TRANSFORM_FORMATS } from '../constants.js';
 import getDatabase from '../database/index.js';
 import env from '../env.js';
-import { ForbiddenException } from '../exceptions/forbidden.js';
-import { IllegalAssetTransformation } from '../exceptions/illegal-asset-transformation.js';
-import { RangeNotSatisfiableException } from '../exceptions/range-not-satisfiable.js';
-import { ServiceUnavailableException } from '../exceptions/service-unavailable.js';
+import { ForbiddenError, IllegalAssetTransformationError, RangeNotSatisfiableError, ServiceUnavailableError, } from '../errors/index.js';
 import logger from '../logger.js';
 import { getStorage } from '../storage/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
@@ -39,23 +36,23 @@ export class AssetsService {
          */
         const isValidUUID = validateUUID(id, 4);
         if (isValidUUID === false)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         if (systemPublicKeys.includes(id) === false && this.accountability?.admin !== true) {
             await this.authorizationService.checkAccess('read', 'directus_files', id);
         }
         const file = (await this.knex.select('*').from('directus_files').where({ id }).first());
         if (!file)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const exists = await storage.location(file.storage).exists(file.filename_disk);
         if (!exists)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         if (range) {
             const missingRangeLimits = range.start === undefined && range.end === undefined;
             const endBeforeStart = range.start !== undefined && range.end !== undefined && range.end <= range.start;
             const startOverflow = range.start !== undefined && range.start >= file.filesize;
             const endUnderflow = range.end !== undefined && range.end <= 0;
             if (missingRangeLimits || endBeforeStart || startOverflow || endUnderflow) {
-                throw new RangeNotSatisfiableException(range);
+                throw new RangeNotSatisfiableError({ range });
             }
             const lastByte = file.filesize - 1;
             if (range.end) {
@@ -106,12 +103,14 @@ export class AssetsService {
                 !height ||
                 width > env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION'] ||
                 height > env['ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION']) {
-                throw new IllegalAssetTransformation(`Image is too large to be transformed, or image size couldn't be determined.`);
+                logger.warn(`Image is too large to be transformed, or image size couldn't be determined.`);
+                throw new IllegalAssetTransformationError({ invalidTransformations: ['width', 'height'] });
             }
             const { queue, process } = sharp.counters();
             if (queue + process > env['ASSETS_TRANSFORM_MAX_CONCURRENT']) {
-                throw new ServiceUnavailableException('Server too busy', {
+                throw new ServiceUnavailableError({
                     service: 'files',
+                    reason: 'Server too busy',
                 });
             }
             const readStream = await storage.location(file.storage).read(file.filename_disk, range);

package/dist/services/authentication.js

@@ -7,7 +7,8 @@ import { DEFAULT_AUTH_PROVIDER } from '../constants.js';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { InvalidCredentialsException, InvalidOTPException, InvalidProviderException, UserSuspendedException, } from '../exceptions/index.js';
+import { InvalidCredentialsError, InvalidProviderError, UserSuspendedError } from '../errors/index.js';
+import { InvalidOtpError } from '../errors/index.js';
 import { createRateLimiter } from '../rate-limiter.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { stall } from '../utils/stall.js';
@@ -76,16 +77,16 @@ export class AuthenticationService {
             emitStatus('fail');
             if (user?.status === 'suspended') {
                 await stall(STALL_TIME, timeStart);
-                throw new UserSuspendedException();
+                throw new UserSuspendedError();
             }
             else {
                 await stall(STALL_TIME, timeStart);
-                throw new InvalidCredentialsException();
+                throw new InvalidCredentialsError();
             }
         }
         else if (user.provider !== providerName) {
             await stall(STALL_TIME, timeStart);
-            throw new InvalidProviderException();
+            throw new InvalidProviderError();
         }
         const settingsService = new SettingsService({
             knex: this.knex,
@@ -117,7 +118,7 @@ export class AuthenticationService {
         if (user.tfa_secret && !otp) {
             emitStatus('fail');
             await stall(STALL_TIME, timeStart);
-            throw new InvalidOTPException(`"otp" is required`);
+            throw new InvalidOtpError();
         }
         if (user.tfa_secret && otp) {
             const tfaService = new TFAService({ knex: this.knex, schema: this.schema });
@@ -125,7 +126,7 @@ export class AuthenticationService {
             if (otpValid === false) {
                 emitStatus('fail');
                 await stall(STALL_TIME, timeStart);
-                throw new InvalidOTPException(`"otp" is invalid`);
+                throw new InvalidOtpError();
             }
         }
         const tokenPayload = {
@@ -188,7 +189,7 @@ export class AuthenticationService {
         const STALL_TIME = env['LOGIN_STALL_TIME'];
         const timeStart = performance.now();
         if (!refreshToken) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         const record = await this.knex
             .select({
@@ -230,17 +231,17 @@ export class AuthenticationService {
         })
             .first();
         if (!record || (!record.share_id && !record.user_id)) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         if (record.user_id && record.user_status !== 'active') {
             await this.knex('directus_sessions').where({ token: refreshToken }).del();
             if (record.user_status === 'suspended') {
                 await stall(STALL_TIME, timeStart);
-                throw new UserSuspendedException();
+                throw new UserSuspendedError();
             }
             else {
                 await stall(STALL_TIME, timeStart);
-                throw new InvalidCredentialsException();
+                throw new InvalidCredentialsError();
             }
         }
         if (record.user_id) {
@@ -330,7 +331,7 @@ export class AuthenticationService {
             .where('id', userID)
             .first();
         if (!user) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         const provider = getAuthProvider(user.provider);
         await provider.verify(clone(user), password);

package/dist/services/authorization.d.ts

@@ -1,6 +1,6 @@
 import type { Accountability, PermissionsAction, SchemaOverview } from '@directus/types';
 import type { Knex } from 'knex';
-import type { AbstractServiceOptions, AST, Item, PrimaryKey } from '../types/index.js';
+import type { AST, AbstractServiceOptions, Item, PrimaryKey } from '../types/index.js';
 import { PayloadService } from './payload.js';
 export declare class AuthorizationService {
     knex: Knex;

package/dist/services/authorization.js

@@ -1,9 +1,9 @@
-import { FailedValidationException } from '@directus/exceptions';
 import { validatePayload } from '@directus/utils';
+import { FailedValidationError, joiValidationErrorItemToErrorExtensions } from '@directus/validation';
 import { cloneDeep, flatten, isArray, isNil, merge, reduce, uniq, uniqWith } from 'lodash-es';
 import { GENERATE_SPECIAL } from '../constants.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/forbidden.js';
 import { getRelationInfo } from '../utils/get-relation-info.js';
 import { stripFunction } from '../utils/strip-function.js';
 import { ItemsService } from './items.js';
@@ -31,7 +31,7 @@ export class AuthorizationService {
         // If the permissions don't match the collections, you don't have permission to read all of them
         const uniqueCollectionsRequestedCount = uniq(collectionsRequested.map(({ collection }) => collection)).length;
         if (uniqueCollectionsRequestedCount !== permissionsForCollections.length) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         validateFields(ast);
         validateFilterPermissions(ast, this.schema, action, this.accountability);
@@ -94,7 +94,7 @@ export class AuthorizationService {
                             if (column === '*')
                                 continue;
                             if (allowedFields.includes(column) === false)
-                                throw new ForbiddenException();
+                                throw new ForbiddenError();
                         }
                     }
                 }
@@ -107,7 +107,7 @@ export class AuthorizationService {
                         continue;
                     const fieldKey = stripFunction(childNode.name);
                     if (allowedFields.includes(fieldKey) === false) {
-                        throw new ForbiddenException();
+                        throw new ForbiddenError();
                     }
                 }
             }
@@ -189,7 +189,7 @@ export class AuthorizationService {
                             });
                             // Filter key not found in parent collection
                             if (!relation)
-                                throw new ForbiddenException();
+                                throw new ForbiddenError();
                             const relatedCollectionName = relation.related_collection === parentCollection ? relation.collection : relation.related_collection;
                             // Add the `item` field to the required permissions
                             (result[relatedCollectionName] || (result[relatedCollectionName] = new Set())).add(field);
@@ -211,7 +211,7 @@ export class AuthorizationService {
                             });
                             // Filter key not found in parent collection
                             if (!relation)
-                                throw new ForbiddenException();
+                                throw new ForbiddenError();
                             parentCollection =
                                 relation.related_collection === parentCollection ? relation.collection : relation.related_collection;
                             (result[parentCollection] || (result[parentCollection] = new Set())).add(filterKey);
@@ -262,14 +262,14 @@ export class AuthorizationService {
                     if (action !== 'read' && collection === rootCollection) {
                         const actionPermission = accountability?.permissions?.find((permission) => permission.collection === collection && permission.action === action);
                         if (!actionPermission || !actionPermission.fields) {
-                            throw new ForbiddenException();
+                            throw new ForbiddenError();
                         }
                         allowedFields = permission?.fields
                             ? [...permission.fields, schema.collections[collection].primary]
                             : [schema.collections[collection].primary];
                     }
                     else if (!permission || !permission.fields) {
-                        throw new ForbiddenException();
+                        throw new ForbiddenError();
                     }
                     else {
                         allowedFields = permission.fields;
@@ -288,7 +288,7 @@ export class AuthorizationService {
                             originalFieldName = aliasMap[fieldName];
                         }
                         if (!allowedFields.includes(originalFieldName)) {
-                            throw new ForbiddenException();
+                            throw new ForbiddenError();
                         }
                     }
                 }
@@ -356,14 +356,14 @@ export class AuthorizationService {
                 return permission.collection === collection && permission.action === action;
             });
             if (!permission)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             // Check if you have permission to access the fields you're trying to access
             const allowedFields = permission.fields || [];
             if (allowedFields.includes('*') === false) {
                 const keysInData = Object.keys(payload);
                 const invalidKeys = keysInData.filter((fieldKey) => allowedFields.includes(fieldKey) === false);
                 if (invalidKeys.length > 0) {
-                    throw new ForbiddenException();
+                    throw new ForbiddenError();
                 }
             }
         }
@@ -412,7 +412,7 @@ export class AuthorizationService {
             }
         }
         const validationErrors = [];
-        validationErrors.push(...flatten(validatePayload(permission.validation, payloadWithPresets).map((error) => error.details.map((details) => new FailedValidationException(details)))));
+        validationErrors.push(...flatten(validatePayload(permission.validation, payloadWithPresets).map((error) => error.details.map((details) => new FailedValidationError(joiValidationErrorItemToErrorExtensions(details))))));
         if (validationErrors.length > 0)
             throw validationErrors;
         return payloadWithPresets;
@@ -431,14 +431,14 @@ export class AuthorizationService {
         if (Array.isArray(pk)) {
             const result = await itemsService.readMany(pk, { ...query, limit: pk.length }, { permissionsAction: action });
             if (!result)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             if (result.length !== pk.length)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
         }
         else {
             const result = await itemsService.readOne(pk, query, { permissionsAction: action });
             if (!result)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
         }
     }
 }

package/dist/services/collections.js

@@ -8,7 +8,7 @@ import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemCollectionRows } from '../database/system-data/collections/index.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { FieldsService } from '../services/fields.js';
 import { ItemsService } from '../services/items.js';
 import { getSchema } from '../utils/get-schema.js';
@@ -36,12 +36,12 @@ export class CollectionsService {
      */
     async createOne(payload, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (!payload.collection)
-            throw new InvalidPayloadException(`"collection" is required`);
+            throw new InvalidPayloadError({ reason: `"collection" is required` });
         if (payload.collection.startsWith('directus_')) {
-            throw new InvalidPayloadException(`Collections can't start with "directus_"`);
+            throw new InvalidPayloadError({ reason: `Collections can't start with "directus_"` });
         }
         const nestedActionEvents = [];
         try {
@@ -51,7 +51,7 @@ export class CollectionsService {
                 ...Object.keys(this.schema.collections),
             ];
             if (existingCollections.includes(payload.collection)) {
-                throw new InvalidPayloadException(`Collection "${payload.collection}" already exists.`);
+                throw new InvalidPayloadError({ reason: `Collection "${payload.collection}" already exists` });
             }
             // Create the collection/fields in a transaction so it'll be reverted in case of errors or
             // permission problems. This might not work reliably in MySQL, as it doesn't support DDL in
@@ -255,7 +255,7 @@ export class CollectionsService {
     async readOne(collectionKey) {
         const result = await this.readMany([collectionKey]);
         if (result.length === 0)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         return result[0];
     }
     /**
@@ -270,7 +270,7 @@ export class CollectionsService {
                 const collectionsYouHavePermissionToRead = permissions.map(({ collection }) => collection);
                 for (const collectionKey of collectionKeys) {
                     if (collectionsYouHavePermissionToRead.includes(collectionKey) === false) {
-                        throw new ForbiddenException();
+                        throw new ForbiddenError();
                     }
                 }
             }
@@ -283,7 +283,7 @@ export class CollectionsService {
      */
     async updateOne(collectionKey, data, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const nestedActionEvents = [];
         try {
@@ -336,10 +336,10 @@ export class CollectionsService {
      */
     async updateBatch(data, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (!Array.isArray(data)) {
-            throw new InvalidPayloadException('Input should be an array of collection changes.');
+            throw new InvalidPayloadError({ reason: 'Input should be an array of collection changes' });
         }
         const collectionKey = 'collection';
         const collectionKeys = [];
@@ -352,8 +352,9 @@ export class CollectionsService {
                     schema: this.schema,
                 });
                 for (const payload of data) {
-                    if (!payload[collectionKey])
-                        throw new InvalidPayloadException(`Collection in update misses collection key.`);
+                    if (!payload[collectionKey]) {
+                        throw new InvalidPayloadError({ reason: `Collection in update misses collection key` });
+                    }
                     await collectionItemsService.updateOne(payload[collectionKey], omit(payload, collectionKey), {
                         autoPurgeCache: false,
                         autoPurgeSystemCache: false,
@@ -385,7 +386,7 @@ export class CollectionsService {
      */
     async updateMany(collectionKeys, data, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const nestedActionEvents = [];
         try {
@@ -427,14 +428,14 @@ export class CollectionsService {
      */
     async deleteOne(collectionKey, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const nestedActionEvents = [];
         try {
             const collections = await this.readByQuery();
             const collectionToBeDeleted = collections.find((collection) => collection.collection === collectionKey);
             if (!!collectionToBeDeleted === false) {
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             }
             await this.knex.transaction(async (trx) => {
                 if (collectionToBeDeleted.schema) {
@@ -531,7 +532,7 @@ export class CollectionsService {
      */
     async deleteMany(collectionKeys, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const nestedActionEvents = [];
         try {

package/dist/services/fields.js

@@ -4,12 +4,12 @@ import { addFieldFlag, toArray } from '@directus/utils';
 import { isEqual, isNil } from 'lodash-es';
 import { clearSystemCache, getCache } from '../cache.js';
 import { ALIAS_TYPES } from '../constants.js';
+import { translateDatabaseError } from '../database/errors/translate.js';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemFieldRows } from '../database/system-data/fields/index.js';
 import emitter from '../emitter.js';
-import { translateDatabaseError } from '../exceptions/database/translate.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from '../services/items.js';
 import { PayloadService } from '../services/payload.js';
 import getDefaultValue from '../utils/get-default-value.js';
@@ -48,7 +48,7 @@ export class FieldsService {
     async readAll(collection) {
         let fields;
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const nonAuthorizedItemsService = new ItemsService('directus_fields', {
             knex: this.knex,
@@ -125,7 +125,7 @@ export class FieldsService {
                 allowedFieldsInCollection[permission.collection] = permission.fields ?? [];
             });
             if (collection && collection in allowedFieldsInCollection === false) {
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             }
             return result.filter((field) => {
                 if (field.collection in allowedFieldsInCollection === false)
@@ -151,17 +151,17 @@ export class FieldsService {
     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();
             }
         }
         let column = undefined;
@@ -179,7 +179,7 @@ export class FieldsService {
             // Do nothing
         }
         if (!column && !fieldInfo)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const type = getLocalType(column, fieldInfo);
         const columnWithCastDefaultValue = column
             ? {
@@ -199,7 +199,7 @@ export class FieldsService {
     async createField(collection, field, table, // allows collection creation to
     opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];
@@ -208,7 +208,9 @@ export class FieldsService {
                 isNil(await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()) === false;
             // Check if field already exists, either as a column, or as a row in directus_fields
             if (exists) {
-                throw new InvalidPayloadException(`Field "${field.field}" already exists in collection "${collection}"`);
+                throw new InvalidPayloadError({
+                    reason: `Field "${field.field}" already exists in collection "${collection}"`,
+                });
             }
             // Add flag for specific database type overrides
             const flagToAdd = this.helpers.date.fieldFlagForField(field.type);
@@ -287,7 +289,7 @@ export class FieldsService {
     }
     async updateField(collection, field, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];
@@ -307,7 +309,7 @@ export class FieldsService {
                 (hookAdjustedField.type === 'alias' ||
                     this.schema.collections[collection].fields[field.field]?.type === 'alias') &&
                 hookAdjustedField.type !== (this.schema.collections[collection].fields[field.field]?.type ?? 'alias')) {
-                throw new InvalidPayloadException('Alias type cannot be changed');
+                throw new InvalidPayloadError({ reason: 'Alias type cannot be changed' });
             }
             if (hookAdjustedField.schema) {
                 const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
@@ -384,7 +386,7 @@ export class FieldsService {
     }
     async deleteField(collection, field, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];
@@ -551,7 +553,7 @@ export class FieldsService {
             column = table[field.type](field.field);
         }
         else {
-            throw new InvalidPayloadException(`Illegal type passed: "${field.type}"`);
+            throw new InvalidPayloadError({ reason: `Illegal type passed: "${field.type}"` });
         }
         if (field.schema?.default_value !== undefined) {
             if (typeof field.schema.default_value === 'string' &&