@directus/api 11.1.0 → 12.0.0

package/dist/controllers/utils.js

@@ -3,7 +3,7 @@ import Busboy from 'busboy';
 import { Router } from 'express';
 import Joi from 'joi';
 import { flushCaches } from '../cache.js';
-import { ForbiddenException, InvalidPayloadException, InvalidQueryException, UnsupportedMediaTypeException, } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError, InvalidQueryError, UnsupportedMediaTypeError } from '../errors/index.js';
 import collectionExists from '../middleware/collection-exists.js';
 import { respond } from '../middleware/respond.js';
 import { ExportService, ImportService } from '../services/import-export.js';
@@ -16,24 +16,24 @@ const router = Router();
 router.get('/random/string', asyncHandler(async (req, res) => {
     const { nanoid } = await import('nanoid');
     if (req.query && req.query['length'] && Number(req.query['length']) > 500) {
-        throw new InvalidQueryException(`"length" can't be more than 500 characters`);
+        throw new InvalidQueryError({ reason: `"length" can't be more than 500 characters` });
     }
     const string = nanoid(req.query?.['length'] ? Number(req.query['length']) : 32);
     return res.json({ data: string });
 }));
 router.post('/hash/generate', asyncHandler(async (req, res) => {
     if (!req.body?.string) {
-        throw new InvalidPayloadException(`"string" is required`);
+        throw new InvalidPayloadError({ reason: `"string" is required` });
     }
     const hash = await generateHash(req.body.string);
     return res.json({ data: hash });
 }));
 router.post('/hash/verify', asyncHandler(async (req, res) => {
     if (!req.body?.string) {
-        throw new InvalidPayloadException(`"string" is required`);
+        throw new InvalidPayloadError({ reason: `"string" is required` });
     }
     if (!req.body?.hash) {
-        throw new InvalidPayloadException(`"hash" is required`);
+        throw new InvalidPayloadError({ reason: `"hash" is required` });
     }
     const result = await argon2.verify(req.body.hash, req.body.string);
     return res.json({ data: result });
@@ -45,7 +45,7 @@ const SortSchema = Joi.object({
 router.post('/sort/:collection', collectionExists, asyncHandler(async (req, res) => {
     const { error } = SortSchema.validate(req.body);
     if (error)
-        throw new InvalidPayloadException(error.message);
+        throw new InvalidPayloadError({ reason: error.message });
     const service = new UtilsService({
         accountability: req.accountability,
         schema: req.schema,
@@ -63,7 +63,7 @@ router.post('/revert/:revision', asyncHandler(async (req, _res, next) => {
 }), respond);
 router.post('/import/:collection', collectionExists, asyncHandler(async (req, res, next) => {
     if (req.is('multipart/form-data') === false) {
-        throw new UnsupportedMediaTypeException(`Unsupported Content-Type header`);
+        throw new UnsupportedMediaTypeError({ mediaType: req.headers['content-type'], where: 'Content-Type header' });
     }
     const service = new ImportService({
         accountability: req.accountability,
@@ -94,10 +94,10 @@ router.post('/import/:collection', collectionExists, asyncHandler(async (req, re
 }));
 router.post('/export/:collection', collectionExists, asyncHandler(async (req, _res, next) => {
     if (!req.body.query) {
-        throw new InvalidPayloadException(`"query" is required.`);
+        throw new InvalidPayloadError({ reason: `"query" is required` });
     }
     if (!req.body.format) {
-        throw new InvalidPayloadException(`"format" is required.`);
+        throw new InvalidPayloadError({ reason: `"format" is required` });
     }
     const service = new ExportService({
         accountability: req.accountability,
@@ -112,7 +112,7 @@ router.post('/export/:collection', collectionExists, asyncHandler(async (req, _r
 }), respond);
 router.post('/cache/clear', asyncHandler(async (req, res) => {
     if (req.accountability?.admin !== true) {
-        throw new ForbiddenException();
+        throw new ForbiddenError();
     }
     await flushCaches(true);
     res.status(200).end();

package/dist/controllers/webhooks.js

@@ -1,5 +1,6 @@
+import { isDirectusError } from '@directus/errors';
 import express from 'express';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ErrorCode } from '../errors/index.js';
 import { respond } from '../middleware/respond.js';
 import useCollection from '../middleware/use-collection.js';
 import { validateBatch } from '../middleware/validate-batch.js';
@@ -34,7 +35,7 @@ router.post('/', asyncHandler(async (req, res, next) => {
         }
     }
     catch (error) {
-        if (error instanceof ForbiddenException) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
             return next();
         }
         throw error;
@@ -84,7 +85,7 @@ router.patch('/', validateBatch('update'), asyncHandler(async (req, res, next) =
         res.locals['payload'] = { data: result };
     }
     catch (error) {
-        if (error instanceof ForbiddenException) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
             return next();
         }
         throw error;
@@ -102,7 +103,7 @@ router.patch('/:pk', asyncHandler(async (req, res, next) => {
         res.locals['payload'] = { data: item || null };
     }
     catch (error) {
-        if (error instanceof ForbiddenException) {
+        if (isDirectusError(error, ErrorCode.Forbidden)) {
             return next();
         }
         throw error;

package/dist/{exceptions/database → database/errors}/dialects/mssql.js

@@ -1,10 +1,5 @@
-import getDatabase from '../../../database/index.js';
-import { ContainsNullValuesException } from '../contains-null-values.js';
-import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
-import { NotNullViolationException } from '../not-null-violation.js';
-import { RecordNotUniqueException } from '../record-not-unique.js';
-import { ValueOutOfRangeException } from '../value-out-of-range.js';
-import { ValueTooLongException } from '../value-too-long.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
+import getDatabase from '../../index.js';
 var MSSQLErrorCodes;
 (function (MSSQLErrorCodes) {
     MSSQLErrorCodes[MSSQLErrorCodes["FOREIGN_KEY_VIOLATION"] = 547] = "FOREIGN_KEY_VIOLATION";
@@ -70,11 +65,9 @@ async function uniqueViolation(error) {
         collection = constraintUsage?.collection;
         field = constraintUsage?.field;
     }
-    const invalid = parenMatches[parenMatches.length - 1]?.slice(1, -1);
-    return new RecordNotUniqueException(field, {
+    return new RecordNotUniqueError({
         collection,
         field,
-        invalid,
     });
 }
 function numericValueOutOfRange(error) {
@@ -92,12 +85,9 @@ function numericValueOutOfRange(error) {
      * - Arithmetic overflow error for data type tinyint, value = 50000.
      */
     const field = null;
-    const parts = error.message.split(' ');
-    const invalid = parts[parts.length - 1].slice(0, -1);
-    return new ValueOutOfRangeException(field, {
+    return new ValueOutOfRangeError({
         collection,
         field,
-        invalid,
     });
 }
 function valueLimitViolation(error) {
@@ -109,7 +99,7 @@ function valueLimitViolation(error) {
         return error;
     const collection = bracketMatches[0].slice(1, -1);
     const field = quoteMatches[1].slice(1, -1);
-    return new ValueTooLongException(field, {
+    return new ValueTooLongError({
         collection,
         field,
     });
@@ -124,9 +114,9 @@ function notNullViolation(error) {
     const collection = bracketMatches[0].slice(1, -1);
     const field = quoteMatches[0].slice(1, -1);
     if (error.message.includes('Cannot insert the value NULL into column')) {
-        return new ContainsNullValuesException(field, { collection, field });
+        return new ContainsNullValuesError({ collection, field });
     }
-    return new NotNullViolationException(field, {
+    return new NotNullViolationError({
         collection,
         field,
     });
@@ -145,7 +135,7 @@ function foreignKeyViolation(error) {
     const underscoreParts = underscoreMatches[0].split('__');
     const collection = underscoreParts[1];
     const field = underscoreParts[2];
-    return new InvalidForeignKeyException(field, {
+    return new InvalidForeignKeyError({
         collection,
         field,
     });

package/dist/{exceptions/database → database/errors}/dialects/mysql.js

@@ -1,9 +1,4 @@
-import { ContainsNullValuesException } from '../contains-null-values.js';
-import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
-import { NotNullViolationException } from '../not-null-violation.js';
-import { RecordNotUniqueException } from '../record-not-unique.js';
-import { ValueOutOfRangeException } from '../value-out-of-range.js';
-import { ValueTooLongException } from '../value-too-long.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
 var MySQLErrorCodes;
 (function (MySQLErrorCodes) {
     MySQLErrorCodes["UNIQUE_VIOLATION"] = "ER_DUP_ENTRY";
@@ -51,11 +46,9 @@ function uniqueViolation(error) {
         if (indexName?.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
             field = indexName?.slice(collection.length + 1, -7);
         }
-        const invalid = matches[0]?.slice(1, -1);
-        return new RecordNotUniqueException(field, {
+        return new RecordNotUniqueError({
             collection,
             field,
-            invalid,
         });
     }
     else {
@@ -66,11 +59,9 @@ function uniqueViolation(error) {
         if (indexName?.startsWith(`${collection}_`) && indexName.endsWith('_unique')) {
             field = indexName?.slice(collection.length + 1, -7);
         }
-        const invalid = matches[0]?.slice(1, -1);
-        return new RecordNotUniqueException(field, {
+        return new RecordNotUniqueError({
             collection,
             field,
-            invalid,
         });
     }
 }
@@ -83,7 +74,7 @@ function numericValueOutOfRange(error) {
         return error;
     const collection = tickMatches[0]?.slice(1, -1);
     const field = quoteMatches[0]?.slice(1, -1);
-    return new ValueOutOfRangeException(field, {
+    return new ValueOutOfRangeError({
         collection,
         field,
     });
@@ -97,7 +88,7 @@ function valueLimitViolation(error) {
         return error;
     const collection = tickMatches[0]?.slice(1, -1);
     const field = quoteMatches[0]?.slice(1, -1);
-    return new ValueTooLongException(field, {
+    return new ValueTooLongError({
         collection,
         field,
     });
@@ -111,7 +102,7 @@ function notNullViolation(error) {
         return error;
     const collection = tickMatches[0]?.slice(1, -1);
     const field = quoteMatches[0]?.slice(1, -1);
-    return new NotNullViolationException(field, {
+    return new NotNullViolationError({
         collection,
         field,
     });
@@ -125,11 +116,9 @@ function foreignKeyViolation(error) {
         return error;
     const collection = tickMatches[1].slice(1, -1);
     const field = tickMatches[3].slice(1, -1);
-    const invalid = parenMatches[1].slice(1, -1);
-    return new InvalidForeignKeyException(field, {
+    return new InvalidForeignKeyError({
         collection,
         field,
-        invalid,
     });
 }
 function containsNullValues(error) {
@@ -139,6 +128,7 @@ function containsNullValues(error) {
     const tickMatches = error.sql.match(betweenTicks);
     if (!tickMatches)
         return error;
+    const collection = tickMatches[0].slice(1, -1);
     const field = tickMatches[1].slice(1, -1);
-    return new ContainsNullValuesException(field);
+    return new ContainsNullValuesError({ collection, field });
 }

package/dist/{exceptions/database → database/errors}/dialects/oracle.js

@@ -1,4 +1,4 @@
-import { ContainsNullValuesException } from '../contains-null-values.js';
+import { ContainsNullValuesError } from '../../../errors/index.js';
 var OracleErrorCodes;
 (function (OracleErrorCodes) {
     OracleErrorCodes[OracleErrorCodes["CONTAINS_NULL_VALUES"] = 2296] = "CONTAINS_NULL_VALUES";
@@ -19,5 +19,5 @@ function containsNullValues(error) {
         return error;
     const collection = matches[0].slice(1, -1);
     const field = matches[1].slice(1, -1);
-    return new ContainsNullValuesException(field, { collection, field });
+    return new ContainsNullValuesError({ collection, field });
 }

package/dist/{exceptions/database → database/errors}/dialects/postgres.js

@@ -1,9 +1,4 @@
-import { ContainsNullValuesException } from '../contains-null-values.js';
-import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
-import { NotNullViolationException } from '../not-null-violation.js';
-import { RecordNotUniqueException } from '../record-not-unique.js';
-import { ValueOutOfRangeException } from '../value-out-of-range.js';
-import { ValueTooLongException } from '../value-too-long.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, ValueOutOfRangeError, ValueTooLongError, } from '../../../errors/index.js';
 var PostgresErrorCodes;
 (function (PostgresErrorCodes) {
     PostgresErrorCodes["FOREIGN_KEY_VIOLATION"] = "23503";
@@ -36,11 +31,9 @@ function uniqueViolation(error) {
         return error;
     const collection = table;
     const field = matches[0].slice(1, -1);
-    const invalid = matches[1].slice(1, -1);
-    return new RecordNotUniqueException(field, {
+    return new RecordNotUniqueError({
         collection,
         field,
-        invalid,
     });
 }
 function numericValueOutOfRange(error) {
@@ -50,11 +43,9 @@ function numericValueOutOfRange(error) {
         return error;
     const collection = matches[0].slice(1, -1);
     const field = null;
-    const invalid = matches[2].slice(1, -1);
-    return new ValueOutOfRangeException(field, {
+    return new ValueOutOfRangeError({
         collection,
         field,
-        invalid,
     });
 }
 function valueLimitViolation(error) {
@@ -68,7 +59,7 @@ function valueLimitViolation(error) {
         return error;
     const collection = matches[0].slice(1, -1);
     const field = null;
-    return new ValueTooLongException(field, {
+    return new ValueTooLongError({
         collection,
         field,
     });
@@ -78,9 +69,9 @@ function notNullViolation(error) {
     if (!column)
         return error;
     if (error.message.endsWith('contains null values')) {
-        return new ContainsNullValuesException(column, { collection: table, field: column });
+        return new ContainsNullValuesError({ collection: table, field: column });
     }
-    return new NotNullViolationException(column, {
+    return new NotNullViolationError({
         collection: table,
         field: column,
     });
@@ -93,10 +84,8 @@ function foreignKeyViolation(error) {
         return error;
     const collection = table;
     const field = matches[0].slice(1, -1);
-    const invalid = matches[1].slice(1, -1);
-    return new InvalidForeignKeyException(field, {
+    return new InvalidForeignKeyError({
         collection,
         field,
-        invalid,
     });
 }

package/dist/{exceptions/database → database/errors}/dialects/sqlite.js

@@ -1,10 +1,7 @@
-import { ContainsNullValuesException } from '../contains-null-values.js';
-import { InvalidForeignKeyException } from '../invalid-foreign-key.js';
-import { NotNullViolationException } from '../not-null-violation.js';
-import { RecordNotUniqueException } from '../record-not-unique.js';
+import { ContainsNullValuesError, InvalidForeignKeyError, NotNullViolationError, RecordNotUniqueError, } from '../../../errors/index.js';
 // NOTE:
-// - Sqlite doesn't have varchar with length support, so no ValueTooLongException
-// - Sqlite doesn't have a max range for numbers, so no ValueOutOfRangeException
+// - Sqlite doesn't have varchar with length support, so no ValueTooLongError
+// - Sqlite doesn't have a max range for numbers, so no ValueOutOfRangeError
 export function extractError(error) {
     if (error.message.includes('SQLITE_CONSTRAINT: NOT NULL')) {
         return notNullConstraint(error);
@@ -14,7 +11,7 @@ export function extractError(error) {
         const [table, column] = errorParts[errorParts.length - 1].split('.');
         if (!table || !column)
             return error;
-        return new RecordNotUniqueException(column, {
+        return new RecordNotUniqueError({
             collection: table,
             field: column,
         });
@@ -25,7 +22,7 @@ export function extractError(error) {
          * SQLite doesn't return any useful information in it's foreign key constraint failed error, so
          * we can't extract the table/column/value accurately
          */
-        return new InvalidForeignKeyException(null);
+        return new InvalidForeignKeyError({ collection: null, field: null });
     }
     return error;
 }
@@ -40,9 +37,9 @@ function notNullConstraint(error) {
         // start with _knex_temp. The best we can do in this case is check for that, and use it to
         // decide between NotNullViolation and ContainsNullValues
         if (table.startsWith('_knex_temp_alter')) {
-            return new ContainsNullValuesException(column);
+            return new ContainsNullValuesError({ collection: table, field: column });
         }
-        return new NotNullViolationException(column, {
+        return new NotNullViolationError({
             collection: table,
             field: column,
         });

package/dist/{exceptions/database → database/errors}/translate.js

@@ -1,4 +1,4 @@
-import getDatabase, { getDatabaseClient } from '../../database/index.js';
+import getDatabase, { getDatabaseClient } from '../index.js';
 import emitter from '../../emitter.js';
 import { extractError as mssql } from './dialects/mssql.js';
 import { extractError as mysql } from './dialects/mysql.js';

package/dist/database/migrations/run.js

@@ -14,7 +14,7 @@ export default async function run(database, direction, log = true) {
     const customMigrationsPath = path.resolve(env['EXTENSIONS_PATH'], 'migrations');
     let customMigrationFiles = ((await fse.pathExists(customMigrationsPath)) && (await fse.readdir(customMigrationsPath))) || [];
     migrationFiles = migrationFiles.filter((file) => /^[0-9]+[A-Z]-[^.]+\.(?:js|ts)$/.test(file));
-    customMigrationFiles = customMigrationFiles.filter((file) => /\.(c|m)?js$/.test(file));
+    customMigrationFiles = customMigrationFiles.filter((file) => file.includes('-') && /\.(c|m)?js$/.test(file));
     const completedMigrations = await database.select('*').from('directus_migrations').orderBy('version');
     const migrations = [
         ...migrationFiles.map((path) => parseFilePath(path)),
@@ -56,6 +56,9 @@ export default async function run(database, direction, log = true) {
             throw Error('Nothing to upgrade');
         }
         const { up } = await import(`file://${nextVersion.file}`);
+        if (!up) {
+            logger.warn(`Couldn't find the "up" function from migration ${nextVersion.file}`);
+        }
         if (log) {
             logger.info(`Applying ${nextVersion.name}...`);
         }
@@ -73,6 +76,9 @@ export default async function run(database, direction, log = true) {
             throw new Error("Couldn't find migration");
         }
         const { down } = await import(`file://${migration.file}`);
+        if (!down) {
+            logger.warn(`Couldn't find the "down" function from migration ${migration.file}`);
+        }
         if (log) {
             logger.info(`Undoing ${migration.name}...`);
         }
@@ -86,6 +92,9 @@ export default async function run(database, direction, log = true) {
             if (migration.completed === false) {
                 needsCacheFlush = true;
                 const { up } = getModuleDefault(await import(`file://${migration.file}`));
+                if (!up) {
+                    logger.warn(`Couldn't find the "up" function from migration ${migration.file}`);
+                }
                 if (log) {
                     logger.info(`Applying ${migration.name}...`);
                 }

package/dist/env.js

@@ -42,6 +42,12 @@ const allowedEnvironmentVars = [
     'REFRESH_TOKEN_COOKIE_SECURE',
     'REFRESH_TOKEN_COOKIE_SAME_SITE',
     'REFRESH_TOKEN_COOKIE_NAME',
+    'REDIS',
+    'REDIS_HOST',
+    'REDIS_PORT',
+    'REDIS_USERNAME',
+    'REDIS_PASSWORD',
+    'REDIS_DB',
     'LOGIN_STALL_TIME',
     'PASSWORD_RESET_URL_ALLOW_LIST',
     'USER_INVITE_URL_ALLOW_LIST',
@@ -76,11 +82,6 @@ const allowedEnvironmentVars = [
     'CACHE_NAMESPACE',
     'CACHE_STORE',
     'CACHE_STATUS_HEADER',
-    'CACHE_REDIS',
-    'CACHE_REDIS_HOST',
-    'CACHE_REDIS_PORT',
-    'CACHE_REDIS_PASSWORD',
-    'CACHE_MEMCACHE',
     'CACHE_VALUE_MAX_SIZE',
     'CACHE_SKIP_ALLOWED',
     'CACHE_HEALTHCHECK_THRESHOLD',
@@ -158,17 +159,9 @@ const allowedEnvironmentVars = [
     // messenger
     'MESSENGER_STORE',
     'MESSENGER_NAMESPACE',
-    'MESSENGER_REDIS',
-    'MESSENGER_REDIS_HOST',
-    'MESSENGER_REDIS_PORT',
-    'MESSENGER_REDIS_PASSWORD',
     // synchronization
     'SYNCHRONIZATION_STORE',
     'SYNCHRONIZATION_NAMESPACE',
-    'SYNCHRONIZATION_REDIS',
-    'SYNCHRONIZATION_REDIS_HOST',
-    'SYNCHRONIZATION_REDIS_PORT',
-    'SYNCHRONIZATION_REDIS_PASSWORD',
     // emails
     'EMAIL_FROM',
     'EMAIL_TRANSPORT',

package/dist/errors/codes.d.ts

@@ -0,0 +1,29 @@
+export declare enum ErrorCode {
+    ContainsNullValues = "CONTAINS_NULL_VALUES",
+    ContentTooLarge = "CONTENT_TOO_LARGE",
+    Forbidden = "FORBIDDEN",
+    IllegalAssetTransformation = "ILLEGAL_ASSET_TRANSFORMATION",
+    InvalidCredentials = "INVALID_CREDENTIALS",
+    InvalidForeignKey = "INVALID_FOREIGN_KEY",
+    InvalidIp = "INVALID_IP",
+    InvalidOtp = "INVALID_OTP",
+    InvalidPayload = "INVALID_PAYLOAD",
+    InvalidProvider = "INVALID_PROVIDER",
+    InvalidProviderConfig = "INVALID_PROVIDER_CONFIG",
+    InvalidQuery = "INVALID_QUERY",
+    InvalidToken = "INVALID_TOKEN",
+    MethodNotAllowed = "METHOD_NOT_ALLOWED",
+    NotNullViolation = "NOT_NULL_VIOLATION",
+    RangeNotSatisfiable = "RANGE_NOT_SATISFIABLE",
+    RecordNotUnique = "RECORD_NOT_UNIQUE",
+    RequestsExceeded = "REQUESTS_EXCEEDED",
+    RouteNotFound = "ROUTE_NOT_FOUND",
+    ServiceUnavailable = "SERVICE_UNAVAILABLE",
+    TokenExpired = "TOKEN_EXPIRED",
+    UnexpectedResponse = "UNEXPECTED_RESPONSE",
+    UnprocessableContent = "UNPROCESSABLE_CONTENT",
+    UnsupportedMediaType = "UNSUPPORTED_MEDIA_TYPE",
+    UserSuspended = "USER_SUSPENDED",
+    ValueOutOfRange = "VALUE_OUT_OF_RANGE",
+    ValueTooLong = "VALUE_TOO_LONG"
+}

package/dist/errors/codes.js

@@ -0,0 +1,30 @@
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ContainsNullValues"] = "CONTAINS_NULL_VALUES";
+    ErrorCode["ContentTooLarge"] = "CONTENT_TOO_LARGE";
+    ErrorCode["Forbidden"] = "FORBIDDEN";
+    ErrorCode["IllegalAssetTransformation"] = "ILLEGAL_ASSET_TRANSFORMATION";
+    ErrorCode["InvalidCredentials"] = "INVALID_CREDENTIALS";
+    ErrorCode["InvalidForeignKey"] = "INVALID_FOREIGN_KEY";
+    ErrorCode["InvalidIp"] = "INVALID_IP";
+    ErrorCode["InvalidOtp"] = "INVALID_OTP";
+    ErrorCode["InvalidPayload"] = "INVALID_PAYLOAD";
+    ErrorCode["InvalidProvider"] = "INVALID_PROVIDER";
+    ErrorCode["InvalidProviderConfig"] = "INVALID_PROVIDER_CONFIG";
+    ErrorCode["InvalidQuery"] = "INVALID_QUERY";
+    ErrorCode["InvalidToken"] = "INVALID_TOKEN";
+    ErrorCode["MethodNotAllowed"] = "METHOD_NOT_ALLOWED";
+    ErrorCode["NotNullViolation"] = "NOT_NULL_VIOLATION";
+    ErrorCode["RangeNotSatisfiable"] = "RANGE_NOT_SATISFIABLE";
+    ErrorCode["RecordNotUnique"] = "RECORD_NOT_UNIQUE";
+    ErrorCode["RequestsExceeded"] = "REQUESTS_EXCEEDED";
+    ErrorCode["RouteNotFound"] = "ROUTE_NOT_FOUND";
+    ErrorCode["ServiceUnavailable"] = "SERVICE_UNAVAILABLE";
+    ErrorCode["TokenExpired"] = "TOKEN_EXPIRED";
+    ErrorCode["UnexpectedResponse"] = "UNEXPECTED_RESPONSE";
+    ErrorCode["UnprocessableContent"] = "UNPROCESSABLE_CONTENT";
+    ErrorCode["UnsupportedMediaType"] = "UNSUPPORTED_MEDIA_TYPE";
+    ErrorCode["UserSuspended"] = "USER_SUSPENDED";
+    ErrorCode["ValueOutOfRange"] = "VALUE_OUT_OF_RANGE";
+    ErrorCode["ValueTooLong"] = "VALUE_TOO_LONG";
+})(ErrorCode || (ErrorCode = {}));

package/dist/errors/contains-null-values.d.ts

@@ -0,0 +1,7 @@
+interface ContainsNullValuesErrorExtensions {
+    collection: string;
+    field: string;
+}
+export declare const messageConstructor: ({ collection, field }: ContainsNullValuesErrorExtensions) => string;
+export declare const ContainsNullValuesError: import("@directus/errors").DirectusErrorConstructor<ContainsNullValuesErrorExtensions>;
+export {};

package/dist/errors/contains-null-values.js

@@ -0,0 +1,4 @@
+import { createError } from '@directus/errors';
+import { ErrorCode } from './codes.js';
+export const messageConstructor = ({ collection, field }) => `Field "${field}" in collection "${collection}" contains null values.`;
+export const ContainsNullValuesError = createError(ErrorCode.ContainsNullValues, messageConstructor, 400);

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';