@directus/api 11.1.0 → 12.0.0

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.js

@@ -29,11 +29,11 @@ export class MessengerRedis {
     pub;
     sub;
     constructor() {
-        const config = getConfigFromEnv('MESSENGER_REDIS');
+        const config = getConfigFromEnv('REDIS');
         const env = getEnv();
-        this.pub = new Redis(env['MESSENGER_REDIS'] ?? config);
-        this.sub = new Redis(env['MESSENGER_REDIS'] ?? config);
-        this.namespace = env['MESSENGER_NAMESPACE'] ?? 'directus';
+        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));

package/dist/middleware/authenticate.js

@@ -2,8 +2,8 @@ import { isEqual } from 'lodash-es';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import asyncHandler from '../utils/async-handler.js';
-import { getIPFromReq } from '../utils/get-ip-from-req.js';
 import { getAccountabilityForToken } from '../utils/get-accountability-for-token.js';
+import { getIPFromReq } from '../utils/get-ip-from-req.js';
 /**
  * Verify the passed JWT and assign the user ID and role to `req`
  */

package/dist/middleware/check-ip.js

@@ -1,5 +1,5 @@
 import getDatabase from '../database/index.js';
-import { InvalidIPException } from '../exceptions/index.js';
+import { InvalidIpError } from '../errors/index.js';
 import asyncHandler from '../utils/async-handler.js';
 export const checkIP = asyncHandler(async (req, _res, next) => {
     const database = getDatabase();
@@ -13,6 +13,6 @@ export const checkIP = asyncHandler(async (req, _res, next) => {
     const role = await query.first();
     const ipAllowlist = (role?.ip_access || '').split(',').filter((ip) => ip);
     if (ipAllowlist.length > 0 && ipAllowlist.includes(req.accountability.ip) === false)
-        throw new InvalidIPException();
+        throw new InvalidIpError();
     return next();
 });

package/dist/middleware/collection-exists.js

@@ -2,13 +2,13 @@
  * Check if requested collection exists, and save it to req.collection
  */
 import { systemCollectionRows } from '../database/system-data/collections/index.js';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/index.js';
 import asyncHandler from '../utils/async-handler.js';
 const collectionExists = asyncHandler(async (req, _res, next) => {
     if (!req.params['collection'])
         return next();
     if (req.params['collection'] in req.schema.collections === false) {
-        throw new ForbiddenException();
+        throw new ForbiddenError();
     }
     req.collection = req.params['collection'];
     if (req.collection.startsWith('directus_')) {

package/dist/middleware/error-handler.js

@@ -1,9 +1,9 @@
-import { BaseException } from '@directus/exceptions';
+import { isDirectusError } from '@directus/errors';
 import { toArray } from '@directus/utils';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
 import env from '../env.js';
-import { MethodNotAllowedException } from '../exceptions/index.js';
+import { ErrorCode, MethodNotAllowedError } from '../errors/index.js';
 import logger from '../logger.js';
 // Note: keep all 4 parameters here. That's how Express recognizes it's the error handler, even if
 // we don't use next
@@ -12,7 +12,7 @@ const errorHandler = (err, req, res, _next) => {
         errors: [],
     };
     const errors = toArray(err);
-    if (errors.some((err) => err instanceof BaseException === false)) {
+    if (errors.some((err) => isDirectusError(err) === false)) {
         res.status(500);
     }
     else {
@@ -33,18 +33,18 @@ const errorHandler = (err, req, res, _next) => {
                 stack: err.stack,
             };
         }
-        if (err instanceof BaseException) {
+        if (isDirectusError(err)) {
             logger.debug(err);
             res.status(err.status);
             payload.errors.push({
                 message: err.message,
                 extensions: {
                     code: err.code,
-                    ...err.extensions,
+                    ...(err.extensions ?? {}),
                 },
             });
-            if (err instanceof MethodNotAllowedException) {
-                res.header('Allow', err.extensions['allow'].join(', '));
+            if (isDirectusError(err, ErrorCode.MethodNotAllowed)) {
+                res.header('Allow', err.extensions.allowed.join(', '));
             }
         }
         else {

package/dist/middleware/graphql.js

@@ -1,10 +1,11 @@
 import { parseJSON } from '@directus/utils';
 import { getOperationAST, parse, Source } from 'graphql';
-import { InvalidPayloadException, InvalidQueryException, MethodNotAllowedException } from '../exceptions/index.js';
+import { InvalidPayloadError, InvalidQueryError, MethodNotAllowedError } from '../errors/index.js';
+import { GraphQLValidationError } from '../services/graphql/errors/validation.js';
 import asyncHandler from '../utils/async-handler.js';
 export const parseGraphQL = asyncHandler(async (req, res, next) => {
     if (req.method !== 'GET' && req.method !== 'POST') {
-        throw new MethodNotAllowedException('GraphQL only supports GET and POST requests.', { allow: ['GET', 'POST'] });
+        throw new MethodNotAllowedError({ allowed: ['GET', 'POST'], current: req.method });
     }
     let query = null;
     let variables = null;
@@ -17,7 +18,7 @@ export const parseGraphQL = asyncHandler(async (req, res, next) => {
                 variables = parseJSON(req.query['variables']);
             }
             catch {
-                throw new InvalidQueryException(`Variables are invalid JSON.`);
+                throw new InvalidQueryError({ reason: `Variables are invalid JSON` });
             }
         }
         else {
@@ -31,21 +32,22 @@ export const parseGraphQL = asyncHandler(async (req, res, next) => {
         operationName = req.body.operationName || null;
     }
     if (query === null) {
-        throw new InvalidPayloadException('Must provide query string.');
+        throw new InvalidPayloadError({ reason: 'Must provide query string' });
     }
     try {
         document = parse(new Source(query));
     }
     catch (err) {
-        throw new InvalidPayloadException(`GraphQL schema validation error.`, {
-            graphqlErrors: [err],
+        throw new GraphQLValidationError({
+            errors: [err],
         });
     }
     const operationAST = getOperationAST(document, operationName);
-    // You can only do `query` through GET
+    // Mutations can't happen through GET requests
     if (req.method === 'GET' && operationAST?.operation !== 'query') {
-        throw new MethodNotAllowedException(`Can only perform a ${operationAST?.operation} from a POST request.`, {
-            allow: ['POST'],
+        throw new MethodNotAllowedError({
+            allowed: ['POST'],
+            current: 'GET',
         });
     }
     // Prevent caching responses when mutations are made

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

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