@directus/api 11.0.1 → 12.0.0

package/dist/services/payload.js

@@ -7,7 +7,7 @@ import { v4 as uuid } from 'uuid';
 import { parse as wktToGeoJSON } from 'wellknown';
 import { getHelpers } from '../database/helpers/index.js';
 import getDatabase from '../database/index.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { generateHash } from '../utils/generate-hash.js';
 import { ItemsService } from './items.js';
 /**
@@ -262,14 +262,14 @@ export class PayloadService {
                         if (dateColumn.type === 'date') {
                             const parsedDate = parseISO(value);
                             if (!isValid(parsedDate)) {
-                                throw new InvalidPayloadException(`Invalid Date format in field "${dateColumn.field}"`);
+                                throw new InvalidPayloadError({ reason: `Invalid Date format in field "${dateColumn.field}"` });
                             }
                             payload[name] = parsedDate;
                         }
                         if (dateColumn.type === 'dateTime') {
                             const parsedDate = parseISO(value);
                             if (!isValid(parsedDate)) {
-                                throw new InvalidPayloadException(`Invalid DateTime format in field "${dateColumn.field}"`);
+                                throw new InvalidPayloadError({ reason: `Invalid DateTime format in field "${dateColumn.field}"` });
                             }
                             payload[name] = parsedDate;
                         }
@@ -318,11 +318,15 @@ export class PayloadService {
                 continue;
             const relatedCollection = payload[relation.meta.one_collection_field];
             if (!relatedCollection) {
-                throw new InvalidPayloadException(`Can't update nested record "${relation.collection}.${relation.field}" without field "${relation.collection}.${relation.meta.one_collection_field}" being set`);
+                throw new InvalidPayloadError({
+                    reason: `Can't update nested record "${relation.collection}.${relation.field}" without field "${relation.collection}.${relation.meta.one_collection_field}" being set`,
+                });
             }
             const allowedCollections = relation.meta.one_allowed_collections;
             if (allowedCollections.includes(relatedCollection) === false) {
-                throw new InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`);
+                throw new InvalidPayloadError({
+                    reason: `"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`,
+                });
             }
             const itemsService = new ItemsService(relatedCollection, {
                 accountability: this.accountability,
@@ -474,7 +478,7 @@ export class PayloadService {
                             .where({ [relatedPrimaryKeyField]: record })
                             .first();
                         if (!!existingRecord === false) {
-                            throw new ForbiddenException();
+                            throw new ForbiddenError();
                         }
                         // If the related item is already associated to the current item, and there's no
                         // other updates (which is indicated by the fact that this is just the PK, we can
@@ -542,7 +546,7 @@ export class PayloadService {
                 const alterations = field;
                 const { error } = nestedUpdateSchema.validate(alterations);
                 if (error)
-                    throw new InvalidPayloadException(`Invalid one-to-many update structure: ${error.message}`);
+                    throw new InvalidPayloadError({ reason: `Invalid one-to-many update structure: ${error.message}` });
                 if (alterations.create) {
                     const sortField = relation.meta.sort_field;
                     let createPayload;

package/dist/services/relations.js

@@ -5,7 +5,7 @@ import { getHelpers } from '../database/helpers/index.js';
 import getDatabase, { getSchemaInspector } from '../database/index.js';
 import { systemRelationRows } from '../database/system-data/relations/index.js';
 import emitter from '../emitter.js';
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { getDefaultIndexName } from '../utils/get-default-index-name.js';
 import { getSchema } from '../utils/get-schema.js';
 import { ItemsService } from './items.js';
@@ -37,7 +37,7 @@ export class RelationsService {
     }
     async readAll(collection, opts) {
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         const metaReadQuery = {
             limit: -1,
@@ -64,17 +64,17 @@ export class RelationsService {
     async readOne(collection, field) {
         if (this.accountability && this.accountability.admin !== true) {
             if (this.hasReadAccess === false) {
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             }
             const permissions = this.accountability.permissions?.find((permission) => {
                 return permission.action === 'read' && permission.collection === collection;
             });
             if (!permissions || !permissions.fields)
-                throw new ForbiddenException();
+                throw new ForbiddenError();
             if (permissions.fields.includes('*') === false) {
                 const allowedFields = permissions.fields;
                 if (allowedFields.includes(field) === false)
-                    throw new ForbiddenException();
+                    throw new ForbiddenError();
             }
         }
         const metaRow = await this.relationsItemService.readByQuery({
@@ -98,7 +98,7 @@ export class RelationsService {
         const stitched = this.stitchRelations(metaRow, schemaRow ? [schemaRow] : []);
         const results = await this.filterForbidden(stitched);
         if (results.length === 0) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         return results[0];
     }
@@ -107,30 +107,36 @@ export class RelationsService {
      */
     async createOne(relation, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (!relation.collection) {
-            throw new InvalidPayloadException('"collection" is required');
+            throw new InvalidPayloadError({ reason: '"collection" is required' });
         }
         if (!relation.field) {
-            throw new InvalidPayloadException('"field" is required');
+            throw new InvalidPayloadError({ reason: '"field" is required' });
         }
         if (relation.collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${relation.collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${relation.collection}" doesn't exist` });
         }
         if (relation.field in this.schema.collections[relation.collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${relation.field}" doesn't exist in collection "${relation.collection}"`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" doesn't exist in collection "${relation.collection}"`,
+            });
         }
         // A primary key should not be a foreign key
         if (this.schema.collections[relation.collection].primary === relation.field) {
-            throw new InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" is a primary key`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" in collection "${relation.collection}" is a primary key`,
+            });
         }
         if (relation.related_collection && relation.related_collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${relation.related_collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${relation.related_collection}" doesn't exist` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === relation.collection && existingRelation.field === relation.field);
         if (existingRelation) {
-            throw new InvalidPayloadException(`Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`);
+            throw new InvalidPayloadError({
+                reason: `Field "${relation.field}" in collection "${relation.collection}" already has an associated relationship`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         this.helpers.schema.preRelationChange(relation);
@@ -190,17 +196,19 @@ export class RelationsService {
      */
     async updateOne(collection, field, relation, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
         if (field in this.schema.collections[collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${field}" doesn't exist in collection "${collection}"`);
+            throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
         if (!existingRelation) {
-            throw new InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
+            throw new InvalidPayloadError({
+                reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         this.helpers.schema.preRelationChange(relation);
@@ -273,17 +281,19 @@ export class RelationsService {
      */
     async deleteOne(collection, field, opts) {
         if (this.accountability && this.accountability.admin !== true) {
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         }
         if (collection in this.schema.collections === false) {
-            throw new InvalidPayloadException(`Collection "${collection}" doesn't exist`);
+            throw new InvalidPayloadError({ reason: `Collection "${collection}" doesn't exist` });
         }
         if (field in this.schema.collections[collection].fields === false) {
-            throw new InvalidPayloadException(`Field "${field}" doesn't exist in collection "${collection}"`);
+            throw new InvalidPayloadError({ reason: `Field "${field}" doesn't exist in collection "${collection}"` });
         }
         const existingRelation = this.schema.relations.find((existingRelation) => existingRelation.collection === collection && existingRelation.field === field);
         if (!existingRelation) {
-            throw new InvalidPayloadException(`Field "${field}" in collection "${collection}" doesn't have a relationship.`);
+            throw new InvalidPayloadError({
+                reason: `Field "${field}" in collection "${collection}" doesn't have a relationship.`,
+            });
         }
         const runPostColumnChange = await this.helpers.schema.preColumnChange();
         const nestedActionEvents = [];

package/dist/services/revisions.js

@@ -1,4 +1,4 @@
-import { ForbiddenException, InvalidPayloadException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 export class RevisionsService extends ItemsService {
     constructor(options) {
@@ -7,9 +7,9 @@ export class RevisionsService extends ItemsService {
     async revert(pk) {
         const revision = await super.readOne(pk);
         if (!revision)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         if (!revision['data'])
-            throw new InvalidPayloadException(`Revision doesn't contain data to revert to`);
+            throw new InvalidPayloadError({ reason: `Revision doesn't contain data to revert to` });
         const service = new ItemsService(revision['collection'], {
             accountability: this.accountability,
             knex: this.knex,

package/dist/services/roles.js

@@ -1,4 +1,4 @@
-import { ForbiddenException, UnprocessableEntityException } from '../exceptions/index.js';
+import { ForbiddenError, UnprocessableContentError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 import { PermissionsService } from './permissions.js';
 import { PresetsService } from './presets.js';
@@ -16,13 +16,14 @@ export class RolesService extends ItemsService {
             .andWhere({ admin_access: true })
             .first();
         const otherAdminRolesCount = +(otherAdminRoles?.count || 0);
-        if (otherAdminRolesCount === 0)
-            throw new UnprocessableEntityException(`You can't delete the last admin role.`);
+        if (otherAdminRolesCount === 0) {
+            throw new UnprocessableContentError({ reason: `You can't delete the last admin role` });
+        }
     }
     async checkForOtherAdminUsers(key, users) {
         const role = await this.knex.select('admin_access').from('directus_roles').where('id', '=', key).first();
         if (!role)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         // The users that will now be in this new non-admin role
         let userKeys = [];
         if (Array.isArray(users)) {
@@ -48,7 +49,7 @@ export class RolesService extends ItemsService {
             .first();
         const otherAdminUsersCount = +(otherAdminUsers?.count || 0);
         if (otherAdminUsersCount === 0) {
-            throw new UnprocessableEntityException(`You can't remove the last admin user from the admin role.`);
+            throw new UnprocessableContentError({ reason: `You can't remove the last admin user from the admin role` });
         }
         return;
     }
@@ -59,7 +60,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateOne(key, data, opts);
     }
@@ -73,7 +74,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateBatch(data, opts);
     }
@@ -84,7 +85,7 @@ export class RolesService extends ItemsService {
             }
         }
         catch (err) {
-            (opts || (opts = {})).preMutationException = err;
+            (opts || (opts = {})).preMutationError = err;
         }
         return super.updateMany(keys, data, opts);
     }
@@ -98,7 +99,7 @@ export class RolesService extends ItemsService {
             await this.checkForOtherAdminRoles(keys);
         }
         catch (err) {
-            opts.preMutationException = err;
+            opts.preMutationError = err;
         }
         await this.knex.transaction(async (trx) => {
             const itemsService = new ItemsService('directus_roles', {

package/dist/services/schema.js

@@ -1,8 +1,8 @@
 import getDatabase from '../database/index.js';
-import { ForbiddenException } from '../exceptions/index.js';
+import { ForbiddenError } from '../errors/index.js';
 import { applyDiff } from '../utils/apply-diff.js';
-import { getSnapshot } from '../utils/get-snapshot.js';
 import { getSnapshotDiff } from '../utils/get-snapshot-diff.js';
+import { getSnapshot } from '../utils/get-snapshot.js';
 import { getVersionedHash } from '../utils/get-versioned-hash.js';
 import { validateApplyDiff } from '../utils/validate-diff.js';
 import { validateSnapshot } from '../utils/validate-snapshot.js';
@@ -15,13 +15,13 @@ export class SchemaService {
     }
     async snapshot() {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const currentSnapshot = await getSnapshot({ database: this.knex });
         return currentSnapshot;
     }
     async apply(payload) {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const currentSnapshot = await this.snapshot();
         const snapshotWithHash = this.getHashedSnapshot(currentSnapshot);
         if (!validateApplyDiff(payload, snapshotWithHash))
@@ -30,7 +30,7 @@ export class SchemaService {
     }
     async diff(snapshot, options) {
         if (this.accountability?.admin !== true)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         validateSnapshot(snapshot, options?.force);
         const currentSnapshot = options?.currentSnapshot ?? (await getSnapshot({ database: this.knex }));
         const diff = getSnapshotDiff(currentSnapshot, snapshot);

package/dist/services/server.js

@@ -13,6 +13,7 @@ import { SERVER_ONLINE } from '../server.js';
 import { getStorage } from '../storage/index.js';
 import { version } from '../utils/package.js';
 import { SettingsService } from './settings.js';
+import { toBoolean } from '../utils/to-boolean.js';
 export class ServerService {
     knex;
     accountability;
@@ -67,6 +68,29 @@ export class ServerService {
                 max: Number.isFinite(env['QUERY_LIMIT_MAX']) ? env['QUERY_LIMIT_MAX'] : -1,
             };
         }
+        if (this.accountability?.user) {
+            if (toBoolean(env['WEBSOCKETS_ENABLED'])) {
+                info['websocket'] = {};
+                info['websocket'].rest = toBoolean(env['WEBSOCKETS_REST_ENABLED'])
+                    ? {
+                        authentication: env['WEBSOCKETS_REST_AUTH'],
+                        path: env['WEBSOCKETS_REST_PATH'],
+                    }
+                    : false;
+                info['websocket'].graphql = toBoolean(env['WEBSOCKETS_GRAPHQL_ENABLED'])
+                    ? {
+                        authentication: env['WEBSOCKETS_GRAPHQL_AUTH'],
+                        path: env['WEBSOCKETS_GRAPHQL_PATH'],
+                    }
+                    : false;
+                info['websocket'].heartbeat = toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED'])
+                    ? env['WEBSOCKETS_HEARTBEAT_PERIOD']
+                    : false;
+            }
+            else {
+                info['websocket'] = false;
+            }
+        }
         return info;
     }
     async health() {

package/dist/services/shares.js

@@ -1,7 +1,7 @@
 import argon2 from 'argon2';
 import jwt from 'jsonwebtoken';
 import env from '../env.js';
-import { ForbiddenException, InvalidCredentialsException } from '../exceptions/index.js';
+import { ForbiddenError, InvalidCredentialsError } from '../errors/index.js';
 import { getMilliseconds } from '../utils/get-milliseconds.js';
 import { md } from '../utils/md.js';
 import { Url } from '../utils/url.js';
@@ -51,10 +51,10 @@ export class SharesService extends ItemsService {
         })
             .first();
         if (!record) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         if (record.share_password && !(await argon2.verify(record.share_password, payload['password']))) {
-            throw new InvalidCredentialsException();
+            throw new InvalidCredentialsError();
         }
         await this.knex('directus_shares')
             .update({ times_used: record.share_times_used + 1 })
@@ -96,7 +96,7 @@ export class SharesService extends ItemsService {
      */
     async invite(payload) {
         if (!this.accountability?.user)
-            throw new ForbiddenException();
+            throw new ForbiddenError();
         const share = await this.readOne(payload.share, { fields: ['collection'] });
         const usersService = new UsersService({
             knex: this.knex,

package/dist/services/tfa.js

@@ -1,6 +1,6 @@
 import { authenticator } from 'otplib';
 import getDatabase from '../database/index.js';
-import { InvalidPayloadException } from '../exceptions/index.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
 export class TFAService {
     knex;
@@ -15,17 +15,17 @@ export class TFAService {
         }
         const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
         if (!user?.tfa_secret) {
-            throw new InvalidPayloadException(`User "${key}" doesn't have TFA enabled.`);
+            throw new InvalidPayloadError({ reason: `User "${key}" doesn't have TFA enabled` });
         }
         return authenticator.check(otp, user.tfa_secret);
     }
     async generateTFA(key) {
         const user = await this.knex.select('email', 'tfa_secret').from('directus_users').where({ id: key }).first();
         if (user?.tfa_secret !== null) {
-            throw new InvalidPayloadException('TFA Secret is already set for this user');
+            throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
         if (!user?.email) {
-            throw new InvalidPayloadException('User must have a valid email to enable TFA');
+            throw new InvalidPayloadError({ reason: 'User must have a valid email to enable TFA' });
         }
         const secret = authenticator.generateSecret();
         const project = await this.knex.select('project_name').from('directus_settings').limit(1).first();
@@ -37,10 +37,10 @@ export class TFAService {
     async enableTFA(key, otp, secret) {
         const user = await this.knex.select('tfa_secret').from('directus_users').where({ id: key }).first();
         if (user?.tfa_secret !== null) {
-            throw new InvalidPayloadException('TFA Secret is already set for this user');
+            throw new InvalidPayloadError({ reason: 'TFA Secret is already set for this user' });
         }
         if (!authenticator.check(otp, secret)) {
-            throw new InvalidPayloadException(`"otp" is invalid`);
+            throw new InvalidPayloadError({ reason: `"otp" is invalid` });
         }
         await this.itemsService.updateOne(key, { tfa_secret: secret });
     }

package/dist/services/translations.d.ts

@@ -1,7 +1,7 @@
 import type { Item, PrimaryKey } from '@directus/types';
-import { ItemsService } from './items.js';
-import type { AbstractServiceOptions } from '../types/services.js';
 import type { MutationOptions } from '../types/items.js';
+import type { AbstractServiceOptions } from '../types/services.js';
+import { ItemsService } from './items.js';
 export declare class TranslationsService extends ItemsService {
     constructor(options: AbstractServiceOptions);
     private translationKeyExists;

package/dist/services/translations.js

@@ -1,6 +1,6 @@
 import getDatabase from '../database/index.js';
+import { InvalidPayloadError } from '../errors/index.js';
 import { ItemsService } from './items.js';
-import { InvalidPayloadException } from '../index.js';
 export class TranslationsService extends ItemsService {
     constructor(options) {
         super('directus_translations', options);
@@ -14,20 +14,20 @@ export class TranslationsService extends ItemsService {
     }
     async createOne(data, opts) {
         if (await this.translationKeyExists(data['key'], data['language'])) {
-            throw new InvalidPayloadException('Duplicate key and language combination.');
+            throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
         }
         return await super.createOne(data, opts);
     }
     async updateMany(keys, data, opts) {
         if (keys.length > 0 && 'key' in data && 'language' in data) {
-            throw new InvalidPayloadException('Duplicate key and language combination.');
+            throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
         }
         else if ('key' in data || 'language' in data) {
             const items = await this.readMany(keys);
             for (const item of items) {
                 const updatedData = { ...item, ...data };
                 if (await this.translationKeyExists(updatedData['key'], updatedData['language'])) {
-                    throw new InvalidPayloadException('Duplicate key and language combination.');
+                    throw new InvalidPayloadError({ reason: 'Duplicate key and language combination' });
                 }
             }
         }