@directus/api 11.0.1 → 12.0.0

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,37 +9,30 @@ 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';
 import { CollectionsService } from '../collections.js';
 import { FieldsService } from '../fields.js';
 import { FilesService } from '../files.js';
-import { FlowsService } from '../flows.js';
-import { FoldersService } from '../folders.js';
-import { ItemsService } from '../items.js';
-import { NotificationsService } from '../notifications.js';
-import { OperationsService } from '../operations.js';
-import { PermissionsService } from '../permissions.js';
-import { PresetsService } from '../presets.js';
 import { RelationsService } from '../relations.js';
 import { RevisionsService } from '../revisions.js';
-import { RolesService } from '../roles.js';
 import { ServerService } from '../server.js';
-import { SettingsService } from '../settings.js';
-import { SharesService } from '../shares.js';
 import { SpecificationService } from '../specifications.js';
 import { TFAService } from '../tfa.js';
 import { UsersService } from '../users.js';
 import { UtilsService } from '../utils.js';
-import { WebhooksService } from '../webhooks.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';
@@ -80,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 {
@@ -93,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'])
@@ -123,6 +117,14 @@ export class GraphQLService {
                 ? this.schema
                 : reduceSchema(this.schema, this.accountability?.permissions || null, ['delete']),
         };
+        const subscriptionEventType = schemaComposer.createEnumTC({
+            name: 'EventEnum',
+            values: {
+                create: { value: 'create' },
+                update: { value: 'update' },
+                delete: { value: 'delete' },
+            },
+        });
         const { ReadCollectionTypes } = getReadableTypes();
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes();
         const scopeFilter = (collection) => {
@@ -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),
                     },
@@ -871,6 +885,26 @@ export class GraphQLService {
                         },
                     });
                 }
+                const eventName = `${collection.collection}_mutated`;
+                if (collection.collection in ReadCollectionTypes) {
+                    const subscriptionType = schemaComposer.createObjectTC({
+                        name: eventName,
+                        fields: {
+                            key: new GraphQLNonNull(GraphQLID),
+                            event: subscriptionEventType,
+                            data: ReadCollectionTypes[collection.collection],
+                        },
+                    });
+                    schemaComposer.Subscription.addFields({
+                        [eventName]: {
+                            type: subscriptionType,
+                            args: {
+                                event: subscriptionEventType,
+                            },
+                            subscribe: createSubscriptionGenerator(self, eventName),
+                        },
+                    });
+                }
             }
             for (const relation of schema.read.relations) {
                 if (relation.related_collection) {
@@ -1147,7 +1181,11 @@ export class GraphQLService {
         if (singleton && action === 'update') {
             return await this.upsertSingleton(collection, args['data'], query);
         }
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         const hasQuery = (query.fields || []).length > 0;
         try {
             if (single) {
@@ -1195,7 +1233,11 @@ export class GraphQLService {
      * Execute the read action on the correct service. Checks for singleton as well.
      */
     async read(collection, query) {
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         const result = this.schema.collections[collection].singleton
             ? await service.readSingleton(query, { stripNonRequested: false })
             : await service.readByQuery(query, { stripNonRequested: false });
@@ -1205,7 +1247,11 @@ export class GraphQLService {
      * Upsert and read singleton item
      */
     async upsertSingleton(collection, body, query) {
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         try {
             await service.upsertSingleton(body);
             if ((query.fields || []).length > 0) {
@@ -1405,49 +1451,6 @@ export class GraphQLService {
         set(error, 'extensions.code', error.code);
         return new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
     }
-    /**
-     * Select the correct service for the given collection. This allows the individual services to run
-     * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
-     */
-    getService(collection) {
-        const opts = {
-            knex: this.knex,
-            accountability: this.accountability,
-            schema: this.schema,
-        };
-        switch (collection) {
-            case 'directus_activity':
-                return new ActivityService(opts);
-            case 'directus_files':
-                return new FilesService(opts);
-            case 'directus_folders':
-                return new FoldersService(opts);
-            case 'directus_permissions':
-                return new PermissionsService(opts);
-            case 'directus_presets':
-                return new PresetsService(opts);
-            case 'directus_notifications':
-                return new NotificationsService(opts);
-            case 'directus_revisions':
-                return new RevisionsService(opts);
-            case 'directus_roles':
-                return new RolesService(opts);
-            case 'directus_settings':
-                return new SettingsService(opts);
-            case 'directus_users':
-                return new UsersService(opts);
-            case 'directus_webhooks':
-                return new WebhooksService(opts);
-            case 'directus_shares':
-                return new SharesService(opts);
-            case 'directus_flows':
-                return new FlowsService(opts);
-            case 'directus_operations':
-                return new OperationsService(opts);
-            default:
-                return new ItemsService(collection, opts);
-        }
-    }
     /**
      * 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
@@ -1539,6 +1542,58 @@ export class GraphQLService {
                         },
                     }),
                 },
+                websocket: toBoolean(env['WEBSOCKETS_ENABLED'])
+                    ? {
+                        type: new GraphQLObjectType({
+                            name: 'server_info_websocket',
+                            fields: {
+                                rest: {
+                                    type: toBoolean(env['WEBSOCKETS_REST_ENABLED'])
+                                        ? new GraphQLObjectType({
+                                            name: 'server_info_websocket_rest',
+                                            fields: {
+                                                authentication: {
+                                                    type: new GraphQLEnumType({
+                                                        name: 'server_info_websocket_rest_authentication',
+                                                        values: {
+                                                            public: { value: 'public' },
+                                                            handshake: { value: 'handshake' },
+                                                            strict: { value: 'strict' },
+                                                        },
+                                                    }),
+                                                },
+                                                path: { type: GraphQLString },
+                                            },
+                                        })
+                                        : GraphQLBoolean,
+                                },
+                                graphql: {
+                                    type: toBoolean(env['WEBSOCKETS_GRAPHQL_ENABLED'])
+                                        ? new GraphQLObjectType({
+                                            name: 'server_info_websocket_graphql',
+                                            fields: {
+                                                authentication: {
+                                                    type: new GraphQLEnumType({
+                                                        name: 'server_info_websocket_graphql_authentication',
+                                                        values: {
+                                                            public: { value: 'public' },
+                                                            handshake: { value: 'handshake' },
+                                                            strict: { value: 'strict' },
+                                                        },
+                                                    }),
+                                                },
+                                                path: { type: GraphQLString },
+                                            },
+                                        })
+                                        : GraphQLBoolean,
+                                },
+                                heartbeat: {
+                                    type: toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED']) ? GraphQLInt : GraphQLBoolean,
+                                },
+                            },
+                        }),
+                    }
+                    : GraphQLBoolean,
                 queryLimit: {
                     type: new GraphQLObjectType({
                         name: 'server_info_query_limit',
@@ -1698,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') {
@@ -1738,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;
@@ -1765,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;
                         }
                     }
@@ -1851,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;
@@ -1865,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);
                 },
@@ -1924,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/subscription.d.ts

@@ -0,0 +1,16 @@
+import type { GraphQLService } from './index.js';
+import type { GraphQLResolveInfo } from 'graphql';
+export declare function bindPubSub(): void;
+export declare function createSubscriptionGenerator(self: GraphQLService, event: string): (_x: unknown, _y: unknown, _z: unknown, request: GraphQLResolveInfo) => AsyncGenerator<{
+    [x: string]: {
+        key: any;
+        data: import("../../types/items.js").Item;
+        event: string;
+    };
+} | {
+    [x: string]: {
+        key: any;
+        data: null;
+        event: string;
+    };
+}, void, unknown>;

package/dist/services/graphql/subscription.js

@@ -0,0 +1,77 @@
+import { EventEmitter, on } from 'events';
+import { getMessenger } from '../../messenger.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { ItemsService } from '../items.js';
+const messages = createPubSub(new EventEmitter());
+export function bindPubSub() {
+    const messenger = getMessenger();
+    messenger.subscribe('websocket.event', (message) => {
+        messages.publish(`${message['collection']}_mutated`, message);
+    });
+}
+export function createSubscriptionGenerator(self, event) {
+    return async function* (_x, _y, _z, request) {
+        const fields = parseFields(self, request);
+        const args = parseArguments(request);
+        for await (const payload of messages.subscribe(event)) {
+            const eventData = payload;
+            if ('event' in args && eventData['action'] !== args['event']) {
+                continue; // skip filtered events
+            }
+            const schema = await getSchema();
+            if (eventData['action'] === 'create') {
+                const { collection, key } = eventData;
+                const service = new ItemsService(collection, { schema });
+                const data = await service.readOne(key, { fields });
+                yield { [event]: { key, data, event: 'create' } };
+            }
+            if (eventData['action'] === 'update') {
+                const { collection, keys } = eventData;
+                const service = new ItemsService(collection, { schema });
+                for (const key of keys) {
+                    const data = await service.readOne(key, { fields });
+                    yield { [event]: { key, data, event: 'update' } };
+                }
+            }
+            if (eventData['action'] === 'delete') {
+                const { keys } = eventData;
+                for (const key of keys) {
+                    yield { [event]: { key, data: null, event: 'delete' } };
+                }
+            }
+        }
+    };
+}
+function createPubSub(emitter) {
+    return {
+        publish: (event, payload) => void emitter.emit(event, payload),
+        subscribe: async function* (event) {
+            const asyncIterator = on(emitter, event);
+            for await (const [value] of asyncIterator) {
+                yield value;
+            }
+        },
+    };
+}
+function parseFields(service, request) {
+    const selections = request.fieldNodes[0]?.selectionSet?.selections ?? [];
+    const dataSelections = selections.reduce((result, selection) => {
+        if (selection.kind === 'Field' &&
+            selection.name.value === 'data' &&
+            selection.selectionSet?.kind === 'SelectionSet') {
+            return selection.selectionSet.selections;
+        }
+        return result;
+    }, []);
+    const { fields } = service.getQuery({}, dataSelections, request.variableValues);
+    return fields ?? [];
+}
+function parseArguments(request) {
+    const args = request.fieldNodes[0]?.arguments ?? [];
+    return args.reduce((result, current) => {
+        if ('value' in current.value && typeof current.value.value === 'string') {
+            result[current.name.value] = current.value.value;
+        }
+        return result;
+    }, {});
+}

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] };