@directus/api 11.0.1 → 12.0.0

package/dist/errors/content-too-large.d.ts

@@ -0,0 +1 @@
+export declare const ContentTooLargeError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/content-too-large.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const ContentTooLargeError = createError(ErrorCode.ContentTooLarge, 'Uploaded content is too large.', 413);

package/dist/errors/forbidden.d.ts

@@ -0,0 +1 @@
+export declare const ForbiddenError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/forbidden.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const ForbiddenError = createError(ErrorCode.Forbidden, `You don't have permission to access this.`, 403);

package/dist/errors/hit-rate-limit.d.ts

@@ -0,0 +1,6 @@
+export interface HitRateLimitErrorExtensions {
+    limit: number;
+    reset: Date;
+}
+export declare const messageConstructor: (extensions: HitRateLimitErrorExtensions) => string;
+export declare const HitRateLimitError: import("@directus/errors").DirectusErrorConstructor<HitRateLimitErrorExtensions>;

package/dist/errors/hit-rate-limit.js

@@ -0,0 +1,8 @@
+import { createError } from '@directus/errors';
+import ms from 'ms';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = (extensions) => {
+    const msBeforeNext = extensions.reset.getTime() - Date.now();
+    return `Too many requests, retry after ${ms(msBeforeNext)}.`;
+};
+export const HitRateLimitError = createError(ErrorCode.RequestsExceeded, messageConstructor, 429);

package/dist/errors/illegal-asset-transformation.d.ts

@@ -0,0 +1,4 @@
+export interface IllegalAssetTransformationErrorExtensions {
+    invalidTransformations: string[];
+}
+export declare const IllegalAssetTransformationError: import("@directus/errors").DirectusErrorConstructor<IllegalAssetTransformationErrorExtensions>;

package/dist/errors/illegal-asset-transformation.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const IllegalAssetTransformationError = createError(ErrorCode.IllegalAssetTransformation, 'Illegal asset transformation.', 400);

package/dist/errors/index.d.ts

@@ -0,0 +1,28 @@
+export { ErrorCode } from './codes.js';
+export { ContainsNullValuesError } from './contains-null-values.js';
+export { ContentTooLargeError } from './content-too-large.js';
+export { ForbiddenError } from './forbidden.js';
+export { HitRateLimitError } from './hit-rate-limit.js';
+export { IllegalAssetTransformationError } from './illegal-asset-transformation.js';
+export { InvalidCredentialsError } from './invalid-credentials.js';
+export { InvalidForeignKeyError } from './invalid-foreign-key.js';
+export { InvalidIpError } from './invalid-ip.js';
+export { InvalidOtpError } from './invalid-otp.js';
+export { InvalidPayloadError } from './invalid-payload.js';
+export { InvalidProviderError } from './invalid-provider.js';
+export { InvalidProviderConfigError } from './invalid-provider-config.js';
+export { InvalidQueryError } from './invalid-query.js';
+export { InvalidTokenError } from './invalid-token.js';
+export { MethodNotAllowedError } from './method-not-allowed.js';
+export { NotNullViolationError } from './not-null-violation.js';
+export { RangeNotSatisfiableError } from './range-not-satisfiable.js';
+export { RecordNotUniqueError } from './record-not-unique.js';
+export { RouteNotFoundError } from './route-not-found.js';
+export { ServiceUnavailableError } from './service-unavailable.js';
+export { TokenExpiredError } from './token-expired.js';
+export { UnexpectedResponseError } from './unexpected-response.js';
+export { UnprocessableContentError } from './unprocessable-content.js';
+export { UnsupportedMediaTypeError } from './unsupported-media-type.js';
+export { UserSuspendedError } from './user-suspended.js';
+export { ValueOutOfRangeError } from './value-out-of-range.js';
+export { ValueTooLongError } from './value-too-long.js';

package/dist/errors/index.js

@@ -0,0 +1,28 @@
+export { ErrorCode } from './codes.js';
+export { ContainsNullValuesError } from './contains-null-values.js';
+export { ContentTooLargeError } from './content-too-large.js';
+export { ForbiddenError } from './forbidden.js';
+export { HitRateLimitError } from './hit-rate-limit.js';
+export { IllegalAssetTransformationError } from './illegal-asset-transformation.js';
+export { InvalidCredentialsError } from './invalid-credentials.js';
+export { InvalidForeignKeyError } from './invalid-foreign-key.js';
+export { InvalidIpError } from './invalid-ip.js';
+export { InvalidOtpError } from './invalid-otp.js';
+export { InvalidPayloadError } from './invalid-payload.js';
+export { InvalidProviderError } from './invalid-provider.js';
+export { InvalidProviderConfigError } from './invalid-provider-config.js';
+export { InvalidQueryError } from './invalid-query.js';
+export { InvalidTokenError } from './invalid-token.js';
+export { MethodNotAllowedError } from './method-not-allowed.js';
+export { NotNullViolationError } from './not-null-violation.js';
+export { RangeNotSatisfiableError } from './range-not-satisfiable.js';
+export { RecordNotUniqueError } from './record-not-unique.js';
+export { RouteNotFoundError } from './route-not-found.js';
+export { ServiceUnavailableError } from './service-unavailable.js';
+export { TokenExpiredError } from './token-expired.js';
+export { UnexpectedResponseError } from './unexpected-response.js';
+export { UnprocessableContentError } from './unprocessable-content.js';
+export { UnsupportedMediaTypeError } from './unsupported-media-type.js';
+export { UserSuspendedError } from './user-suspended.js';
+export { ValueOutOfRangeError } from './value-out-of-range.js';
+export { ValueTooLongError } from './value-too-long.js';

package/dist/errors/invalid-credentials.d.ts

@@ -0,0 +1 @@
+export declare const InvalidCredentialsError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/invalid-credentials.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidCredentialsError = createError(ErrorCode.InvalidCredentials, 'Invalid user credentials.', 401);

package/dist/errors/invalid-foreign-key.d.ts

@@ -0,0 +1,6 @@
+export interface InvalidForeignKeyErrorExtensions {
+    collection: string | null;
+    field: string | null;
+}
+export declare const messageConstructor: ({ collection, field }: InvalidForeignKeyErrorExtensions) => string;
+export declare const InvalidForeignKeyError: import("@directus/errors").DirectusErrorConstructor<InvalidForeignKeyErrorExtensions>;

package/dist/errors/invalid-foreign-key.js

@@ -0,0 +1,14 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => {
+    let message = 'Invalid foreign key';
+    if (field) {
+        message += ` for field "${field}"`;
+    }
+    if (collection) {
+        message += ` in collection "${collection}"`;
+    }
+    message += `.`;
+    return message;
+};
+export const InvalidForeignKeyError = createError(ErrorCode.InvalidForeignKey, messageConstructor, 400);

package/dist/errors/invalid-ip.d.ts

@@ -0,0 +1 @@
+export declare const InvalidIpError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/invalid-ip.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidIpError = createError(ErrorCode.InvalidIp, 'Invalid IP address.', 401);

package/dist/errors/invalid-otp.d.ts

@@ -0,0 +1 @@
+export declare const InvalidOtpError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/invalid-otp.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidOtpError = createError(ErrorCode.InvalidOtp, 'Invalid user OTP.', 401);

package/dist/errors/invalid-payload.d.ts

@@ -0,0 +1,5 @@
+export interface InvalidPayloadErrorExtensions {
+    reason: string;
+}
+export declare const messageConstructor: ({ reason }: InvalidPayloadErrorExtensions) => string;
+export declare const InvalidPayloadError: import("@directus/errors").DirectusErrorConstructor<InvalidPayloadErrorExtensions>;

package/dist/errors/invalid-payload.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ reason }) => `Invalid payload. ${reason}.`;
+export const InvalidPayloadError = createError(ErrorCode.InvalidPayload, messageConstructor, 400);

package/dist/errors/invalid-provider-config.d.ts

@@ -0,0 +1,5 @@
+export interface InvalidProviderConfigErrorExtensions {
+    provider: string;
+    reason?: string;
+}
+export declare const InvalidProviderConfigError: import("@directus/errors").DirectusErrorConstructor<InvalidProviderConfigErrorExtensions>;

package/dist/errors/invalid-provider-config.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidProviderConfigError = createError(ErrorCode.InvalidProviderConfig, 'Invalid config.', 503);

package/dist/errors/invalid-provider.d.ts

@@ -0,0 +1 @@
+export declare const InvalidProviderError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/invalid-provider.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidProviderError = createError(ErrorCode.InvalidProvider, 'Invalid provider.', 403);

package/dist/errors/invalid-query.d.ts

@@ -0,0 +1,5 @@
+export interface InvalidQueryErrorExtensions {
+    reason: string;
+}
+export declare const messageConstructor: ({ reason }: InvalidQueryErrorExtensions) => string;
+export declare const InvalidQueryError: import("@directus/errors").DirectusErrorConstructor<InvalidQueryErrorExtensions>;

package/dist/errors/invalid-query.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ reason }) => `Invalid query. ${reason}.`;
+export const InvalidQueryError = createError(ErrorCode.InvalidQuery, messageConstructor, 400);

package/dist/errors/invalid-token.d.ts

@@ -0,0 +1 @@
+export declare const InvalidTokenError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/invalid-token.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const InvalidTokenError = createError(ErrorCode.InvalidToken, 'Invalid token.', 403);

package/dist/errors/method-not-allowed.d.ts

@@ -0,0 +1,6 @@
+export interface MethodNotAllowedErrorExtensions {
+    allowed: string[];
+    current: string;
+}
+export declare const messageConstructor: (extensions: MethodNotAllowedErrorExtensions) => string;
+export declare const MethodNotAllowedError: import("@directus/errors").DirectusErrorConstructor<MethodNotAllowedErrorExtensions>;

package/dist/errors/method-not-allowed.js

@@ -0,0 +1,6 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = (extensions) => `Invalid method "${extensions.current}" used. Should be one of ${extensions.allowed
+    .map((method) => `"${method}"`)
+    .join(', ')}.`;
+export const MethodNotAllowedError = createError(ErrorCode.MethodNotAllowed, messageConstructor, 405);

package/dist/errors/not-null-violation.d.ts

@@ -0,0 +1,6 @@
+export interface NotNullViolationErrorExtensions {
+    collection: string | null;
+    field: string | null;
+}
+export declare const messageConstructor: ({ collection, field }: NotNullViolationErrorExtensions) => string;
+export declare const NotNullViolationError: import("@directus/errors").DirectusErrorConstructor<NotNullViolationErrorExtensions>;

package/dist/errors/not-null-violation.js

@@ -0,0 +1,14 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => {
+    let message = 'Value ';
+    if (field) {
+        message += `for field "${field}" `;
+    }
+    if (collection) {
+        message += `in collection "${collection}" `;
+    }
+    message += `can't be null.`;
+    return message;
+};
+export const NotNullViolationError = createError(ErrorCode.NotNullViolation, messageConstructor, 400);

package/dist/errors/range-not-satisfiable.d.ts

@@ -0,0 +1,7 @@
+import type { Range } from '@directus/storage';
+interface RangeNotSatisfiableErrorExtensions {
+    range: Range;
+}
+export declare const messageConstructor: ({ range }: RangeNotSatisfiableErrorExtensions) => string;
+export declare const RangeNotSatisfiableError: import("@directus/errors").DirectusErrorConstructor<RangeNotSatisfiableErrorExtensions>;
+export {};

package/dist/errors/range-not-satisfiable.js

@@ -0,0 +1,7 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ range }) => {
+    const rangeString = `"${range.start ?? ''}-${range.end ?? ''}"`;
+    return `Range ${rangeString} is invalid or the file's size doesn't match the requested range.`;
+};
+export const RangeNotSatisfiableError = createError(ErrorCode.RangeNotSatisfiable, messageConstructor, 416);

package/dist/errors/record-not-unique.d.ts

@@ -0,0 +1,6 @@
+export interface RecordNotUniqueErrorExtensions {
+    collection: string | null;
+    field: string | null;
+}
+export declare const messageConstructor: ({ collection, field }: RecordNotUniqueErrorExtensions) => string;
+export declare const RecordNotUniqueError: import("@directus/errors").DirectusErrorConstructor<RecordNotUniqueErrorExtensions>;

package/dist/errors/record-not-unique.js

@@ -0,0 +1,14 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => {
+    let message = 'Value ';
+    if (field) {
+        message += `for field "${field}" `;
+    }
+    if (collection) {
+        message += `in collection "${collection}" `;
+    }
+    message += `has to be unique.`;
+    return message;
+};
+export const RecordNotUniqueError = createError(ErrorCode.RecordNotUnique, messageConstructor, 400);

package/dist/errors/route-not-found.d.ts

@@ -0,0 +1,5 @@
+export interface RouteNotFoundErrorExtensions {
+    path: string;
+}
+export declare const messageConstructor: ({ path }: RouteNotFoundErrorExtensions) => string;
+export declare const RouteNotFoundError: import("@directus/errors").DirectusErrorConstructor<RouteNotFoundErrorExtensions>;

package/dist/errors/route-not-found.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ path }) => `Route ${path} doesn't exist.`;
+export const RouteNotFoundError = createError(ErrorCode.RouteNotFound, messageConstructor, 404);

package/dist/errors/service-unavailable.d.ts

@@ -0,0 +1,7 @@
+interface ServiceUnavailableErrorExtensions {
+    service: string;
+    reason: string;
+}
+export declare const messageConstructor: ({ service, reason }: ServiceUnavailableErrorExtensions) => string;
+export declare const ServiceUnavailableError: import("@directus/errors").DirectusErrorConstructor<ServiceUnavailableErrorExtensions>;
+export {};

package/dist/errors/service-unavailable.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ service, reason }) => `Service "${service}" is unavailable. ${reason}.`;
+export const ServiceUnavailableError = createError(ErrorCode.ServiceUnavailable, messageConstructor, 503);

package/dist/errors/token-expired.d.ts

@@ -0,0 +1 @@
+export declare const TokenExpiredError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/token-expired.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const TokenExpiredError = createError(ErrorCode.TokenExpired, 'Token expired.', 401);

package/dist/errors/unexpected-response.d.ts

@@ -0,0 +1 @@
+export declare const UnexpectedResponseError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/unexpected-response.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const UnexpectedResponseError = createError(ErrorCode.UnexpectedResponse, 'Received an unexpected response.', 503);

package/dist/errors/unprocessable-content.d.ts

@@ -0,0 +1,5 @@
+interface UnprocessableContentErrorExtensions {
+    reason: string;
+}
+export declare const UnprocessableContentError: import("@directus/errors").DirectusErrorConstructor<UnprocessableContentErrorExtensions>;
+export {};

package/dist/errors/unprocessable-content.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+const messageConstructor = (extensions) => `Can't process content. ${extensions.reason}.`;
+export const UnprocessableContentError = createError(ErrorCode.UnprocessableContent, messageConstructor, 422);

package/dist/errors/unsupported-media-type.d.ts

@@ -0,0 +1,6 @@
+export interface UnsupportedMediaTypeErrorExtensions {
+    mediaType: string;
+    where: string;
+}
+export declare const messageConstructor: (extensions: UnsupportedMediaTypeErrorExtensions) => string;
+export declare const UnsupportedMediaTypeError: import("@directus/errors").DirectusErrorConstructor<UnsupportedMediaTypeErrorExtensions>;

package/dist/errors/unsupported-media-type.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = (extensions) => `Unsupported media type "${extensions.mediaType}" in ${extensions.where}.`;
+export const UnsupportedMediaTypeError = createError(ErrorCode.UnsupportedMediaType, messageConstructor, 415);

package/dist/errors/user-suspended.d.ts

@@ -0,0 +1 @@
+export declare const UserSuspendedError: import("@directus/errors").DirectusErrorConstructor<void>;

package/dist/errors/user-suspended.js

@@ -0,0 +1,3 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const UserSuspendedError = createError(ErrorCode.UserSuspended, 'User suspended.', 401);

package/dist/errors/value-out-of-range.d.ts

@@ -0,0 +1,6 @@
+export interface ValueOutOfRangeErrorExtensions {
+    collection: string | null;
+    field: string | null;
+}
+export declare const messageConstructor: ({ collection, field }: ValueOutOfRangeErrorExtensions) => string;
+export declare const ValueOutOfRangeError: import("@directus/errors").DirectusErrorConstructor<ValueOutOfRangeErrorExtensions>;

package/dist/errors/value-out-of-range.js

@@ -0,0 +1,14 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => {
+    let message = 'Numeric value ';
+    if (field) {
+        message += `for field "${field}" `;
+    }
+    if (collection) {
+        message += `in collection "${collection}" `;
+    }
+    message += `is out of range.`;
+    return message;
+};
+export const ValueOutOfRangeError = createError(ErrorCode.ValueOutOfRange, messageConstructor, 400);

package/dist/errors/value-too-long.d.ts

@@ -0,0 +1,6 @@
+export interface ValueTooLongErrorExtensions {
+    collection: string | null;
+    field: string | null;
+}
+export declare const messageConstructor: ({ collection, field }: ValueTooLongErrorExtensions) => string;
+export declare const ValueTooLongError: import("@directus/errors").DirectusErrorConstructor<ValueTooLongErrorExtensions>;

package/dist/errors/value-too-long.js

@@ -0,0 +1,14 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => {
+    let message = 'Value ';
+    if (field) {
+        message += `for field "${field}" `;
+    }
+    if (collection) {
+        message += `in collection "${collection}" `;
+    }
+    message += `is too long.`;
+    return message;
+};
+export const ValueTooLongError = createError(ErrorCode.ValueTooLong, messageConstructor, 400);

package/dist/extensions.js

@@ -1,5 +1,4 @@
 import { APP_EXTENSION_TYPES, APP_SHARED_DEPS, HYBRID_EXTENSION_TYPES, JAVASCRIPT_FILE_EXTS, NESTED_EXTENSION_TYPES, } from '@directus/constants';
-import * as sharedExceptions from '@directus/exceptions';
 import { isIn, isTypeIn, pluralize } from '@directus/utils';
 import { ensureExtensionDirs, generateExtensionsEntrypoint, getLocalExtensions, getPackageExtensions, pathToRelativeUrl, resolvePackage, resolvePackageExtensions, } from '@directus/utils/node';
 import aliasDefault from '@rollup/plugin-alias';
@@ -17,7 +16,6 @@ import { rollup } from 'rollup';
 import getDatabase from './database/index.js';
 import emitter, { Emitter } from './emitter.js';
 import env from './env.js';
-import * as exceptions from './exceptions/index.js';
 import { getFlowManager } from './flows.js';
 import logger from './logger.js';
 import * as services from './services/index.js';
@@ -435,7 +433,6 @@ class ExtensionManager {
         };
         register(registerFunctions, {
             services,
-            exceptions: { ...exceptions, ...sharedExceptions },
             env,
             database: getDatabase(),
             emitter: this.apiEmitter,
@@ -450,7 +447,6 @@ class ExtensionManager {
         this.endpointRouter.use(`/${routeName}`, scopedRouter);
         register(scopedRouter, {
             services,
-            exceptions: { ...exceptions, ...sharedExceptions },
             env,
             database: getDatabase(),
             emitter: this.apiEmitter,

package/dist/flows.js

@@ -1,12 +1,11 @@
 import { Action, REDACTED_TEXT } from '@directus/constants';
-import * as sharedExceptions from '@directus/exceptions';
 import { applyOptionsData, isValidJSON, parseJSON, toArray } from '@directus/utils';
 import { omit, pick } from 'lodash-es';
 import { get } from 'micromustache';
 import getDatabase from './database/index.js';
 import emitter from './emitter.js';
 import env from './env.js';
-import * as exceptions from './exceptions/index.js';
+import { ForbiddenError } from './errors/index.js';
 import logger from './logger.js';
 import { getMessenger } from './messenger.js';
 import { ActivityService } from './services/activity.js';
@@ -82,7 +81,7 @@ class FlowManager {
     async runWebhookFlow(id, data, context) {
         if (!(id in this.webhookFlowHandlers)) {
             logger.warn(`Couldn't find webhook or manual triggered flow with id "${id}"`);
-            throw new exceptions.ForbiddenException();
+            throw new ForbiddenError();
         }
         const handler = this.webhookFlowHandlers[id];
         return handler(data, context);
@@ -186,15 +185,15 @@ class FlowManager {
                     const targetCollection = data?.['body'].collection;
                     if (!targetCollection) {
                         logger.warn(`Manual trigger requires "collection" to be specified in the payload`);
-                        throw new exceptions.ForbiddenException();
+                        throw new ForbiddenError();
                     }
                     if (enabledCollections.length === 0) {
                         logger.warn(`There is no collections configured for this manual trigger`);
-                        throw new exceptions.ForbiddenException();
+                        throw new ForbiddenError();
                     }
                     if (!enabledCollections.includes(targetCollection)) {
                         logger.warn(`Specified collection must be one of: ${enabledCollections.join(', ')}.`);
-                        throw new exceptions.ForbiddenException();
+                        throw new ForbiddenError();
                     }
                     if (flow.options['async']) {
                         this.executeFlow(flow, data, context);
@@ -310,7 +309,6 @@ class FlowManager {
         try {
             let result = await handler(options, {
                 services,
-                exceptions: { ...exceptions, ...sharedExceptions },
                 env,
                 database: getDatabase(),
                 logger,
@@ -331,7 +329,7 @@ class FlowManager {
         catch (error) {
             let data;
             if (error instanceof Error) {
-                // make sure we dont expose the stack trace
+                // make sure we don't expose the stack trace
                 data = sanitizeError(error);
             }
             else if (typeof error === 'string') {

package/dist/index.d.ts

@@ -1,3 +1 @@
 export { default as createApp } from './app.js';
-export * from './services/index.js';
-export * from './exceptions/index.js';

package/dist/index.js

@@ -1,3 +1 @@
 export { default as createApp } from './app.js';
-export * from './services/index.js';
-export * from './exceptions/index.js';

package/dist/messenger.d.ts

@@ -3,14 +3,14 @@ export type MessengerSubscriptionCallback = (payload: Record<string, any>) => vo
 export interface Messenger {
     publish: (channel: string, payload: Record<string, any>) => void;
     subscribe: (channel: string, callback: MessengerSubscriptionCallback) => void;
-    unsubscribe: (channel: string) => void;
+    unsubscribe: (channel: string, callback?: MessengerSubscriptionCallback) => void;
 }
 export declare class MessengerMemory implements Messenger {
-    handlers: Record<string, MessengerSubscriptionCallback>;
+    handlers: Record<string, Set<MessengerSubscriptionCallback>>;
     constructor();
     publish(channel: string, payload: Record<string, any>): void;
     subscribe(channel: string, callback: MessengerSubscriptionCallback): void;
-    unsubscribe(channel: string): void;
+    unsubscribe(channel: string, callback?: MessengerSubscriptionCallback): void;
 }
 export declare class MessengerRedis implements Messenger {
     namespace: string;

package/dist/messenger.js

@@ -1,6 +1,6 @@
 import { parseJSON } from '@directus/utils';
 import { Redis } from 'ioredis';
-import env from './env.js';
+import { getEnv } from './env.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
 export class MessengerMemory {
     handlers;
@@ -8,13 +8,20 @@ export class MessengerMemory {
         this.handlers = {};
     }
     publish(channel, payload) {
-        this.handlers[channel]?.(payload);
+        this.handlers[channel]?.forEach((callback) => callback(payload));
     }
     subscribe(channel, callback) {
-        this.handlers[channel] = callback;
+        if (!this.handlers[channel])
+            this.handlers[channel] = new Set();
+        this.handlers[channel]?.add(callback);
     }
-    unsubscribe(channel) {
-        delete this.handlers[channel];
+    unsubscribe(channel, callback) {
+        if (!callback) {
+            delete this.handlers[channel];
+        }
+        else {
+            this.handlers[channel]?.delete(callback);
+        }
     }
 }
 export class MessengerRedis {
@@ -22,10 +29,11 @@ export class MessengerRedis {
     pub;
     sub;
     constructor() {
-        const config = getConfigFromEnv('MESSENGER_REDIS');
-        this.pub = new Redis(env['MESSENGER_REDIS'] ?? config);
-        this.sub = new Redis(env['MESSENGER_REDIS'] ?? config);
-        this.namespace = env['MESSENGER_NAMESPACE'] ?? 'directus';
+        const config = getConfigFromEnv('REDIS');
+        const env = getEnv();
+        this.pub = new Redis(env['REDIS'] ?? config);
+        this.sub = new Redis(env['REDIS'] ?? config);
+        this.namespace = env['MESSENGER_NAMESPACE'] ?? 'directus-messenger';
     }
     publish(channel, payload) {
         this.pub.publish(`${this.namespace}:${channel}`, JSON.stringify(payload));
@@ -47,6 +55,7 @@ let messenger;
 export function getMessenger() {
     if (messenger)
         return messenger;
+    const env = getEnv();
     if (env['MESSENGER_STORE'] === 'redis') {
         messenger = new MessengerRedis();
     }