@directus/api 11.1.0 → 12.0.1

package/dist/services/fields.js

@@ -1,15 +1,15 @@
 import { KNEX_TYPES, REGEX_BETWEEN_PARENS } from '@directus/constants';
 import { createInspector } from '@directus/schema';
 import { addFieldFlag, toArray } from '@directus/utils';
-import { isEqual, isNil } from 'lodash-es';
+import { isEqual, isNil, merge } 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);
@@ -239,8 +241,14 @@ export class FieldsService {
                     }
                 }
                 if (hookAdjustedField.meta) {
+                    const existingSortRecord = await trx
+                        .from('directus_fields')
+                        .where(hookAdjustedField.meta?.group ? { collection, group: hookAdjustedField.meta.group } : { collection })
+                        .max('sort', { as: 'max' })
+                        .first();
+                    const newSortValue = existingSortRecord?.max ? existingSortRecord.max + 1 : 1;
                     await itemsService.createOne({
-                        ...hookAdjustedField.meta,
+                        ...merge({ sort: newSortValue }, hookAdjustedField.meta),
                         collection: collection,
                         field: hookAdjustedField.field,
                     }, { emitEvents: false });
@@ -287,7 +295,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 +315,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 +392,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 +559,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' &&

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;
@@ -10,7 +10,6 @@ export class MetaService {
         this.accountability = options.accountability || null;
         this.schema = options.schema;
     }
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     async getMetaForQuery(collection, query) {
         if (!query || !query.meta)
             return;
@@ -35,7 +34,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 +49,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] };