@directus/api 11.1.0 → 12.0.0

package/dist/services/files.js

@@ -12,7 +12,7 @@ import url from 'url';
 import { SUPPORTED_IMAGE_METADATA_FORMATS } from '../constants.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { ForbiddenException, InvalidPayloadException, ServiceUnavailableException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError } from '../errors/index.js';
 import logger from '../logger.js';
 import { getAxios } from '../request/index.js';
 import { getStorage } from '../storage/index.js';
@@ -67,7 +67,7 @@ export class FilesService extends ItemsService {
             logger.warn(`Couldn't save file ${payload.filename_disk}`);
             logger.warn(err);
             await this.deleteOne(primaryKey);
-            throw new ServiceUnavailableException(`Couldn't save file ${payload.filename_disk}`, { service: 'files' });
+            throw new ServiceUnavailableError({ service: 'files', reason: `Couldn't save file ${payload.filename_disk}` });
         }
         const { size } = await storage.location(data.storage).stat(payload.filename_disk);
         payload.filesize = size;
@@ -202,7 +202,7 @@ export class FilesService extends ItemsService {
     async importOne(importURL, body) {
         const fileCreatePermissions = this.accountability?.permissions?.find((permission) => permission.collection === 'directus_files' && permission.action === 'create');
         if (this.accountability && this.accountability?.admin !== true && !fileCreatePermissions) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         let fileResponse;
         try {
@@ -213,8 +213,9 @@ export class FilesService extends ItemsService {
         }
         catch (err) {
             logger.warn(err, `Couldn't fetch file from URL "${importURL}"`);
-            throw new ServiceUnavailableException(`Couldn't fetch file from url "${importURL}"`, {
+            throw new ServiceUnavailableError({
                 service: 'external-file',
+                reason: `Couldn't fetch file from url "${importURL}"`,
             });
         }
         const parsedURL = url.parse(fileResponse.request.res.responseUrl);
@@ -234,7 +235,7 @@ export class FilesService extends ItemsService {
      */
     async createOne(data, opts) {
         if (!data.type) {
-            throw new InvalidPayloadException(`"type" is required`);
+            throw new InvalidPayloadError({ reason: `"type" is required` });
         }
         const key = await super.createOne(data, opts);
         return key;
@@ -253,7 +254,7 @@ export class FilesService extends ItemsService {
         const storage = await getStorage();
         const files = await super.readMany(keys, { fields: ['id', 'storage'], limit: -1 });
         if (!files) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         await super.deleteMany(keys);
         for (const file of files) {

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

@@ -0,0 +1,6 @@
+import type { GraphQLError } from 'graphql';
+interface GraphQLExecutionErrorExtensions {
+    errors: GraphQLError[];
+}
+export declare const GraphQLExecutionError: import("@directus/errors").DirectusErrorConstructor<GraphQLExecutionErrorExtensions>;
+export {};

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

@@ -0,0 +1,2 @@
+import { createError } from '@directus/errors';
+export const GraphQLExecutionError = createError('GRAPHQL_EXECUTION', 'GraphQL execution error.', 400);

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

@@ -0,0 +1,2 @@
+export { GraphQLExecutionError } from './execution.js';
+export { GraphQLValidationError } from './validation.js';

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

@@ -0,0 +1,2 @@
+export { GraphQLExecutionError } from './execution.js';
+export { GraphQLValidationError } from './validation.js';

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

@@ -0,0 +1,6 @@
+import type { GraphQLError } from 'graphql';
+interface GraphQLValidationErrorExtensions {
+    errors: GraphQLError[];
+}
+export declare const GraphQLValidationError: import("@directus/errors").DirectusErrorConstructor<GraphQLValidationErrorExtensions>;
+export {};

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

@@ -0,0 +1,2 @@
+import { createError } from '@directus/errors';
+export const GraphQLValidationError = createError('GRAPHQL_VALIDATION', 'GraphQL validation error.', 400);

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

@@ -1,4 +1,4 @@
-import type { BaseException } from '@directus/exceptions';
+import type { DirectusError } from '@directus/errors';
 import type { Accountability, Filter, Query, SchemaOverview } from '@directus/types';
 import type { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
 import { GraphQLError, GraphQLSchema } from 'graphql';
@@ -61,7 +61,7 @@ export declare class GraphQLService {
     /**
      * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
      */
-    formatError(error: BaseException | BaseException[]): GraphQLError;
+    formatError(error: DirectusError | DirectusError[]): GraphQLError;
     /**
      * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
      * Effectively merges the selections with the fragments used in those selections

package/dist/services/graphql/index.js

@@ -1,4 +1,5 @@
 import { Action, FUNCTIONS } from '@directus/constants';
+import { isDirectusError } from '@directus/errors';
 import { parseFilterFunctionPath } from '@directus/utils';
 import argon2 from 'argon2';
 import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, GraphQLUnionType, NoSchemaIntrospectionCustomRule, execute, specifiedRules, validate, } from 'graphql';
@@ -8,13 +9,15 @@ import { clearSystemCache, getCache } from '../../cache.js';
 import { DEFAULT_AUTH_PROVIDER, GENERATE_SPECIAL } from '../../constants.js';
 import getDatabase from '../../database/index.js';
 import env from '../../env.js';
-import { ForbiddenException, GraphQLValidationException, InvalidPayloadException } from '../../exceptions/index.js';
+import { ErrorCode, ForbiddenError, InvalidPayloadError } from '../../errors/index.js';
 import { getExtensionManager } from '../../extensions.js';
 import { generateHash } from '../../utils/generate-hash.js';
 import { getGraphQLType } from '../../utils/get-graphql-type.js';
 import { getMilliseconds } from '../../utils/get-milliseconds.js';
+import { getService } from '../../utils/get-service.js';
 import { reduceSchema } from '../../utils/reduce-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
+import { toBoolean } from '../../utils/to-boolean.js';
 import { validateQuery } from '../../utils/validate-query.js';
 import { ActivityService } from '../activity.js';
 import { AuthenticationService } from '../authentication.js';
@@ -28,6 +31,8 @@ import { SpecificationService } from '../specifications.js';
 import { TFAService } from '../tfa.js';
 import { UsersService } from '../users.js';
 import { UtilsService } from '../utils.js';
+import { GraphQLExecutionError, GraphQLValidationError } from './errors/index.js';
+import { createSubscriptionGenerator } from './subscription.js';
 import { GraphQLBigInt } from './types/bigint.js';
 import { GraphQLDate } from './types/date.js';
 import { GraphQLGeoJSON } from './types/geojson.js';
@@ -36,9 +41,6 @@ import { GraphQLStringOrFloat } from './types/string-or-float.js';
 import { GraphQLVoid } from './types/void.js';
 import { addPathToValidationError } from './utils/add-path-to-validation-error.js';
 import processError from './utils/process-error.js';
-import { createSubscriptionGenerator } from './subscription.js';
-import { getService } from '../../utils/get-service.js';
-import { toBoolean } from '../../utils/to-boolean.js';
 const validationRules = Array.from(specifiedRules);
 if (env['GRAPHQL_INTROSPECTION'] === false) {
     validationRules.push(NoSchemaIntrospectionCustomRule);
@@ -72,7 +74,7 @@ export class GraphQLService {
         const schema = this.getSchema();
         const validationErrors = validate(schema, document, validationRules).map((validationError) => addPathToValidationError(validationError));
         if (validationErrors.length > 0) {
-            throw new GraphQLValidationException({ graphqlErrors: validationErrors });
+            throw new GraphQLValidationError({ errors: validationErrors });
         }
         let result;
         try {
@@ -85,7 +87,7 @@ export class GraphQLService {
             });
         }
         catch (err) {
-            throw new InvalidPayloadException('GraphQL execution error.', { graphqlErrors: [err.message] });
+            throw new GraphQLExecutionError({ errors: [err.message] });
         }
         const formattedResult = {};
         if (result['data'])
@@ -431,12 +433,24 @@ export class GraphQLService {
                     _nstarts_with: {
                         type: GraphQLString,
                     },
+                    _istarts_with: {
+                        type: GraphQLString,
+                    },
+                    _nistarts_with: {
+                        type: GraphQLString,
+                    },
                     _ends_with: {
                         type: GraphQLString,
                     },
                     _nends_with: {
                         type: GraphQLString,
                     },
+                    _iends_with: {
+                        type: GraphQLString,
+                    },
+                    _niends_with: {
+                        type: GraphQLString,
+                    },
                     _in: {
                         type: new GraphQLList(GraphQLString),
                     },
@@ -1739,7 +1753,9 @@ export class GraphQLService {
                     });
                     const currentRefreshToken = args['refresh_token'] || req?.cookies[env['REFRESH_TOKEN_COOKIE_NAME']];
                     if (!currentRefreshToken) {
-                        throw new InvalidPayloadException(`"refresh_token" is required in either the JSON payload or Cookie`);
+                        throw new InvalidPayloadError({
+                            reason: `"refresh_token" is required in either the JSON payload or Cookie`,
+                        });
                     }
                     const result = await authenticationService.refresh(currentRefreshToken);
                     if (args['mode'] === 'cookie') {
@@ -1779,7 +1795,9 @@ export class GraphQLService {
                     });
                     const currentRefreshToken = args['refresh_token'] || req?.cookies[env['REFRESH_TOKEN_COOKIE_NAME']];
                     if (!currentRefreshToken) {
-                        throw new InvalidPayloadException(`"refresh_token" is required in either the JSON payload or Cookie`);
+                        throw new InvalidPayloadError({
+                            reason: `"refresh_token" is required in either the JSON payload or Cookie`,
+                        });
                     }
                     await authenticationService.logout(currentRefreshToken);
                     return true;
@@ -1806,7 +1824,7 @@ export class GraphQLService {
                         await service.requestPasswordReset(args['email'], args['reset_url'] || null);
                     }
                     catch (err) {
-                        if (err instanceof InvalidPayloadException) {
+                        if (isDirectusError(err, ErrorCode.InvalidPayload)) {
                             throw err;
                         }
                     }
@@ -1892,7 +1910,7 @@ export class GraphQLService {
                     });
                     const otpValid = await service.verifyOTP(this.accountability.user, args['otp']);
                     if (otpValid === false) {
-                        throw new InvalidPayloadException(`"otp" is invalid`);
+                        throw new InvalidPayloadError({ reason: `"otp" is invalid` });
                     }
                     await service.disableTFA(this.accountability.user);
                     return true;
@@ -1906,7 +1924,7 @@ export class GraphQLService {
                 resolve: async (_, args) => {
                     const { nanoid } = await import('nanoid');
                     if (args['length'] && Number(args['length']) > 500) {
-                        throw new InvalidPayloadException(`"length" can't be more than 500 characters`);
+                        throw new InvalidPayloadError({ reason: `"length" can't be more than 500 characters` });
                     }
                     return nanoid(args['length'] ? Number(args['length']) : 32);
                 },
@@ -1965,7 +1983,7 @@ export class GraphQLService {
                 type: GraphQLVoid,
                 resolve: async () => {
                     if (this.accountability?.admin !== true) {
-                        throw new ForbiddenException();
+                        throw new ForbiddenError();
                     }
                     const { cache } = getCache();
                     await cache?.clear();

package/dist/services/graphql/utils/process-error.js

@@ -1,14 +1,14 @@
-import { BaseException } from '@directus/exceptions';
+import { isDirectusError } from '@directus/errors';
 import logger from '../../../logger.js';
 const processError = (accountability, error) => {
     logger.error(error);
     const { originalError } = error;
-    if (originalError instanceof BaseException) {
+    if (isDirectusError(originalError)) {
         return {
             message: originalError.message,
             extensions: {
                 code: originalError.code,
-                ...originalError.extensions,
+                ...(originalError.extensions ?? {}),
             },
         };
     }

package/dist/services/import-export.js

@@ -14,7 +14,7 @@ import { file as createTmpFile } from 'tmp-promise';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { ForbiddenException, InvalidPayloadException, ServiceUnavailableException, UnsupportedMediaTypeException, } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError, ServiceUnavailableError, UnsupportedMediaTypeError, } from '../errors/index.js';
 import logger from '../logger.js';
 import { getDateFormatted } from '../utils/get-date-formatted.js';
 import { FilesService } from './files.js';
@@ -31,11 +31,11 @@ export class ImportService {
     }
     async import(collection, mimetype, stream) {
         if (this.accountability?.admin !== true && collection.startsWith('directus_'))
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const createPermissions = this.accountability?.permissions?.find((permission) => permission.collection === collection && permission.action === 'create');
         const updatePermissions = this.accountability?.permissions?.find((permission) => permission.collection === collection && permission.action === 'update');
         if (this.accountability?.admin !== true && (!createPermissions || !updatePermissions)) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         switch (mimetype) {
             case 'application/json':
@@ -44,7 +44,7 @@ export class ImportService {
             case 'application/vnd.ms-excel':
                 return await this.importCSV(collection, stream);
             default:
-                throw new UnsupportedMediaTypeException(`Can't import files of type "${mimetype}"`);
+                throw new UnsupportedMediaTypeError({ mediaType: mimetype, where: 'file import' });
         }
     }
     importJSON(collection, stream) {
@@ -67,7 +67,7 @@ export class ImportService {
                 extractJSON.on('error', (err) => {
                     destroyStream(stream);
                     destroyStream(extractJSON);
-                    reject(new InvalidPayloadException(err.message));
+                    reject(new InvalidPayloadError({ reason: err.message }));
                 });
                 saveQueue.error((err) => {
                     reject(err);
@@ -122,7 +122,7 @@ export class ImportService {
                 })
                     .on('error', (err) => {
                     destroyStream(stream);
-                    reject(new InvalidPayloadException(err.message));
+                    reject(new InvalidPayloadError({ reason: err.message }));
                 })
                     .on('end', () => {
                     saveQueue.drain(() => {
@@ -288,6 +288,6 @@ export class ExportService {
         if (format === 'yaml') {
             return toYAML(input);
         }
-        throw new ServiceUnavailableException(`Illegal export type used: "${format}"`, { service: 'export' });
+        throw new ServiceUnavailableError({ service: 'export', reason: `Illegal export type used: "${format}"` });
     }
 }

package/dist/services/index.d.ts

@@ -32,3 +32,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './webhooks.js';
+export * from './websocket.js';

package/dist/services/index.js

@@ -32,3 +32,4 @@ export * from './translations.js';
 export * from './users.js';
 export * from './utils.js';
 export * from './webhooks.js';
+export * from './websocket.js';

package/dist/services/items.js

@@ -6,8 +6,9 @@ import getDatabase from '../database/index.js';
 import runAST from '../database/run-ast.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { translateDatabaseError } from '../exceptions/database/translate.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/index.js';
+import { translateDatabaseError } from '../database/errors/translate.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import getASTFromQuery from '../utils/get-ast-from-query.js';
 import { shouldClearCache } from '../utils/should-clear-cache.js';
 import { validateKeys } from '../utils/validate-keys.js';
@@ -36,7 +37,7 @@ export class ItemsService {
             trackMutations(count) {
                 mutationCount += count;
                 if (mutationCount > maxCount) {
-                    throw new InvalidPayloadException(`Exceeded max batch mutation limit of ${maxCount}.`);
+                    throw new InvalidPayloadError({ reason: `Exceeded max batch mutation limit of ${maxCount}` });
                 }
             },
             getCount() {
@@ -108,8 +109,8 @@ export class ItemsService {
             const payloadWithPresets = this.accountability
                 ? authorizationService.validatePayload('create', this.collection, payloadAfterHooks)
                 : payloadAfterHooks;
-            if (opts.preMutationException) {
-                throw opts.preMutationException;
+            if (opts.preMutationError) {
+                throw opts.preMutationError;
             }
             const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
             const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
@@ -303,7 +304,7 @@ export class ItemsService {
             stripNonRequested: opts?.stripNonRequested !== undefined ? opts.stripNonRequested : true,
         });
         if (records === null) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const filteredRecords = opts?.emitEvents !== false
             ? await emitter.emitFilter(this.eventScope === 'items' ? ['items.read', `${this.collection}.items.read`] : `${this.eventScope}.read`, records, {
@@ -338,7 +339,7 @@ export class ItemsService {
         const queryWithKey = assign({}, query, { filter: filterWithKey });
         const results = await this.readByQuery(queryWithKey, opts);
         if (results.length === 0) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         return results[0];
     }
@@ -380,7 +381,7 @@ export class ItemsService {
      */
     async updateBatch(data, opts = {}) {
         if (!Array.isArray(data)) {
-            throw new InvalidPayloadException('Input should be an array of items.');
+            throw new InvalidPayloadError({ reason: 'Input should be an array of items' });
         }
         if (!opts.mutationTracker)
             opts.mutationTracker = this.createMutationTracker();
@@ -395,7 +396,7 @@ export class ItemsService {
                 });
                 for (const item of data) {
                     if (!item[primaryKeyField])
-                        throw new InvalidPayloadException(`Item in update misses primary key.`);
+                        throw new InvalidPayloadError({ reason: `Item in update misses primary key` });
                     const combinedOpts = Object.assign({ autoPurgeCache: false }, opts);
                     keys.push(await service.updateOne(item[primaryKeyField], omit(item, primaryKeyField), combinedOpts));
                 }
@@ -454,8 +455,8 @@ export class ItemsService {
         const payloadWithPresets = this.accountability
             ? authorizationService.validatePayload('update', this.collection, payloadAfterHooks)
             : payloadAfterHooks;
-        if (opts.preMutationException) {
-            throw opts.preMutationException;
+        if (opts.preMutationError) {
+            throw opts.preMutationError;
         }
         await this.knex.transaction(async (trx) => {
             const payloadService = new PayloadService(this.collection, {
@@ -654,8 +655,8 @@ export class ItemsService {
             });
             await authorizationService.checkAccess('delete', this.collection, keys);
         }
-        if (opts.preMutationException) {
-            throw opts.preMutationException;
+        if (opts.preMutationError) {
+            throw opts.preMutationError;
         }
         if (opts.emitEvents !== false) {
             await emitter.emitFilter(this.eventScope === 'items' ? ['items.delete', `${this.collection}.items.delete`] : `${this.eventScope}.delete`, keys, {

package/dist/services/mail/index.js

@@ -1,13 +1,13 @@
 import fse from 'fs-extra';
 import { Liquid } from 'liquidjs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import getDatabase from '../../database/index.js';
 import env from '../../env.js';
-import { InvalidPayloadException } from '../../exceptions/index.js';
+import { InvalidPayloadError } from '../../errors/index.js';
 import logger from '../../logger.js';
 import getMailer from '../../mailer.js';
 import { Url } from '../../utils/url.js';
-import { fileURLToPath } from 'url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const liquidEngine = new Liquid({
     root: [path.resolve(env['EXTENSIONS_PATH'], 'templates'), path.resolve(__dirname, 'templates')],
@@ -60,7 +60,7 @@ export class MailService {
         const systemTemplatePath = path.join(__dirname, 'templates', template + '.liquid');
         const templatePath = (await fse.pathExists(customTemplatePath)) ? customTemplatePath : systemTemplatePath;
         if ((await fse.pathExists(templatePath)) === false) {
-            throw new InvalidPayloadException(`Template "${template}" doesn't exist.`);
+            throw new InvalidPayloadError({ reason: `Template "${template}" doesn't exist` });
         }
         const templateString = await fse.readFile(templatePath, 'utf8');
         const html = await liquidEngine.parseAndRender(templateString, variables);

package/dist/services/meta.js

@@ -1,5 +1,5 @@
 import getDatabase from '../database/index.js';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/index.js';
 import { applyFilter, applySearch } from '../utils/apply-query.js';
 export class MetaService {
     knex;
@@ -35,7 +35,7 @@ export class MetaService {
                 return permission.action === 'read' && permission.collection === collection;
             });
             if (!permissionsRecord)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             const permissions = permissionsRecord.permissions ?? {};
             applyFilter(this.knex, this.schema, dbQuery, permissions, collection, {});
         }
@@ -50,7 +50,7 @@ export class MetaService {
                 return permission.action === 'read' && permission.collection === collection;
             });
             if (!permissionsRecord)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             const permissions = permissionsRecord.permissions ?? {};
             if (Object.keys(filter).length > 0) {
                 filter = { _and: [permissions, filter] };

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;