@directus/api 11.0.1 → 11.1.0

package/dist/emitter.d.ts

@@ -4,8 +4,9 @@ export declare class Emitter {
     private actionEmitter;
     private initEmitter;
     constructor();
-    emitFilter<T>(event: string | string[], payload: T, meta: Record<string, any>, context: EventContext): Promise<T>;
-    emitAction(event: string | string[], meta: Record<string, any>, context: EventContext): void;
+    private getDefaultContext;
+    emitFilter<T>(event: string | string[], payload: T, meta: Record<string, any>, context?: EventContext | null): Promise<T>;
+    emitAction(event: string | string[], meta: Record<string, any>, context?: EventContext | null): void;
     emitInit(event: string, meta: Record<string, any>): Promise<void>;
     onFilter(event: string, handler: FilterHandler): void;
     onAction(event: string, handler: ActionHandler): void;

package/dist/emitter.js

@@ -1,5 +1,6 @@
 import ee2 from 'eventemitter2';
 import logger from './logger.js';
+import getDatabase from './database/index.js';
 export class Emitter {
     filterEmitter;
     actionEmitter;
@@ -16,7 +17,14 @@ export class Emitter {
         this.actionEmitter = new ee2.EventEmitter2(emitterOptions);
         this.initEmitter = new ee2.EventEmitter2(emitterOptions);
     }
-    async emitFilter(event, payload, meta, context) {
+    getDefaultContext() {
+        return {
+            database: getDatabase(),
+            accountability: null,
+            schema: null,
+        };
+    }
+    async emitFilter(event, payload, meta, context = null) {
         const events = Array.isArray(event) ? event : [event];
         const eventListeners = events.map((event) => ({
             event,
@@ -25,7 +33,7 @@ export class Emitter {
         let updatedPayload = payload;
         for (const { event, listeners } of eventListeners) {
             for (const listener of listeners) {
-                const result = await listener(updatedPayload, { event, ...meta }, context);
+                const result = await listener(updatedPayload, { event, ...meta }, context ?? this.getDefaultContext());
                 if (result !== undefined) {
                     updatedPayload = result;
                 }
@@ -33,10 +41,10 @@ export class Emitter {
         }
         return updatedPayload;
     }
-    emitAction(event, meta, context) {
+    emitAction(event, meta, context = null) {
         const events = Array.isArray(event) ? event : [event];
         for (const event of events) {
-            this.actionEmitter.emitAsync(event, { event, ...meta }, context).catch((err) => {
+            this.actionEmitter.emitAsync(event, { event, ...meta }, context ?? this.getDefaultContext()).catch((err) => {
                 logger.warn(`An error was thrown while executing action "${event}"`);
                 logger.warn(err);
             });

package/dist/env.js

@@ -6,9 +6,10 @@ import { parseJSON, toArray } from '@directus/utils';
 import dotenv from 'dotenv';
 import fs from 'fs';
 import { clone, toNumber, toString } from 'lodash-es';
+import { createRequire } from 'node:module';
 import path from 'path';
 import { requireYAML } from './utils/require-yaml.js';
-import { createRequire } from 'node:module';
+import { toBoolean } from './utils/to-boolean.js';
 const require = createRequire(import.meta.url);
 // keeping this here for now to prevent a circular import to constants.ts
 const allowedEnvironmentVars = [
@@ -200,6 +201,8 @@ const allowedEnvironmentVars = [
     // flows
     'FLOWS_EXEC_ALLOWED_MODULES',
     'FLOWS_ENV_ALLOW_LIST',
+    // websockets
+    'WEBSOCKETS_.+',
 ].map((name) => new RegExp(`^${name}$`));
 const acceptedEnvTypes = ['string', 'number', 'regex', 'array', 'json'];
 const defaults = {
@@ -275,6 +278,17 @@ const defaults = {
     EXPORT_BATCH_SIZE: 5000,
     FILE_METADATA_ALLOW_LIST: 'ifd0.Make,ifd0.Model,exif.FNumber,exif.ExposureTime,exif.FocalLength,exif.ISO',
     GRAPHQL_INTROSPECTION: true,
+    WEBSOCKETS_ENABLED: false,
+    WEBSOCKETS_REST_ENABLED: true,
+    WEBSOCKETS_REST_AUTH: 'handshake',
+    WEBSOCKETS_REST_AUTH_TIMEOUT: 10,
+    WEBSOCKETS_REST_PATH: '/websocket',
+    WEBSOCKETS_GRAPHQL_ENABLED: true,
+    WEBSOCKETS_GRAPHQL_AUTH: 'handshake',
+    WEBSOCKETS_GRAPHQL_AUTH_TIMEOUT: 10,
+    WEBSOCKETS_GRAPHQL_PATH: '/graphql',
+    WEBSOCKETS_HEARTBEAT_ENABLED: true,
+    WEBSOCKETS_HEARTBEAT_PERIOD: 30,
     FLOWS_EXEC_ALLOWED_MODULES: false,
     FLOWS_ENV_ALLOW_LIST: false,
     PRESSURE_LIMITER_ENABLED: true,
@@ -484,6 +498,3 @@ function tryJSON(value) {
         return value;
     }
 }
-function toBoolean(value) {
-    return value === 'true' || value === true || value === '1' || value === 1;
-}

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 {
@@ -23,6 +30,7 @@ export class MessengerRedis {
     sub;
     constructor() {
         const config = getConfigFromEnv('MESSENGER_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';
@@ -47,6 +55,7 @@ let messenger;
 export function getMessenger() {
     if (messenger)
         return messenger;
+    const env = getEnv();
     if (env['MESSENGER_STORE'] === 'redis') {
         messenger = new MessengerRedis();
     }

package/dist/middleware/authenticate.js

@@ -1,12 +1,9 @@
 import { isEqual } from 'lodash-es';
 import getDatabase from '../database/index.js';
 import emitter from '../emitter.js';
-import env from '../env.js';
-import { InvalidCredentialsException } from '../exceptions/index.js';
 import asyncHandler from '../utils/async-handler.js';
 import { getIPFromReq } from '../utils/get-ip-from-req.js';
-import isDirectusJWT from '../utils/is-directus-jwt.js';
-import { verifyAccessJWT } from '../utils/jwt.js';
+import { getAccountabilityForToken } from '../utils/get-accountability-for-token.js';
 /**
  * Verify the passed JWT and assign the user ID and role to `req`
  */
@@ -36,40 +33,7 @@ export const handler = async (req, _res, next) => {
         req.accountability = customAccountability;
         return next();
     }
-    req.accountability = defaultAccountability;
-    if (req.token) {
-        if (isDirectusJWT(req.token)) {
-            const payload = verifyAccessJWT(req.token, env['SECRET']);
-            req.accountability.role = payload.role;
-            req.accountability.admin = payload.admin_access === true || payload.admin_access == 1;
-            req.accountability.app = payload.app_access === true || payload.app_access == 1;
-            if (payload.share)
-                req.accountability.share = payload.share;
-            if (payload.share_scope)
-                req.accountability.share_scope = payload.share_scope;
-            if (payload.id)
-                req.accountability.user = payload.id;
-        }
-        else {
-            // Try finding the user with the provided token
-            const user = await database
-                .select('directus_users.id', 'directus_users.role', 'directus_roles.admin_access', 'directus_roles.app_access')
-                .from('directus_users')
-                .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
-                .where({
-                'directus_users.token': req.token,
-                status: 'active',
-            })
-                .first();
-            if (!user) {
-                throw new InvalidCredentialsException();
-            }
-            req.accountability.user = user.id;
-            req.accountability.role = user.role;
-            req.accountability.admin = user.admin_access === true || user.admin_access == 1;
-            req.accountability.app = user.app_access === true || user.app_access == 1;
-        }
-    }
+    req.accountability = await getAccountabilityForToken(req.token, defaultAccountability);
     return next();
 };
 export default asyncHandler(handler);

package/dist/server.js

@@ -10,6 +10,9 @@ import emitter from './emitter.js';
 import env from './env.js';
 import logger from './logger.js';
 import { getConfigFromEnv } from './utils/get-config-from-env.js';
+import { createSubscriptionController, createWebSocketController, getSubscriptionController, getWebSocketController, } from './websocket/controllers/index.js';
+import { startWebSocketHandlers } from './websocket/handlers/index.js';
+import { toBoolean } from './utils/to-boolean.js';
 export let SERVER_ONLINE = true;
 export async function createServer() {
     const server = http.createServer(await createApp());
@@ -66,6 +69,11 @@ export async function createServer() {
         res.once('finish', complete.bind(null, true));
         res.once('close', complete.bind(null, false));
     });
+    if (toBoolean(env['WEBSOCKETS_ENABLED']) === true) {
+        createSubscriptionController(server);
+        createWebSocketController(server);
+        startWebSocketHandlers();
+    }
     const terminusOptions = {
         timeout: env['SERVER_SHUTDOWN_TIMEOUT'] >= 0 && env['SERVER_SHUTDOWN_TIMEOUT'] < Infinity
             ? env['SERVER_SHUTDOWN_TIMEOUT']
@@ -84,6 +92,8 @@ export async function createServer() {
         SERVER_ONLINE = false;
     }
     async function onSignal() {
+        getSubscriptionController()?.terminate();
+        getWebSocketController()?.terminate();
         const database = getDatabase();
         await database.destroy();
         logger.info('Database connections destroyed');

package/dist/services/graphql/index.d.ts

@@ -5,7 +5,6 @@ import { GraphQLError, GraphQLSchema } from 'graphql';
 import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
 import type { Knex } from 'knex';
 import type { AbstractServiceOptions, GraphQLParams, Item } from '../../types/index.js';
-import { ItemsService } from '../items.js';
 export declare class GraphQLService {
     accountability: Accountability | null;
     knex: Knex;
@@ -63,11 +62,6 @@ export declare class GraphQLService {
      * Convert Directus-Exception into a GraphQL format, so it can be returned by GraphQL properly.
      */
     formatError(error: BaseException | BaseException[]): GraphQLError;
-    /**
-     * Select the correct service for the given collection. This allows the individual services to run
-     * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
-     */
-    getService(collection: string): ItemsService;
     /**
      * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
      * Effectively merges the selections with the fragments used in those selections

package/dist/services/graphql/index.js

@@ -21,24 +21,13 @@ import { AuthenticationService } from '../authentication.js';
 import { CollectionsService } from '../collections.js';
 import { FieldsService } from '../fields.js';
 import { FilesService } from '../files.js';
-import { FlowsService } from '../flows.js';
-import { FoldersService } from '../folders.js';
-import { ItemsService } from '../items.js';
-import { NotificationsService } from '../notifications.js';
-import { OperationsService } from '../operations.js';
-import { PermissionsService } from '../permissions.js';
-import { PresetsService } from '../presets.js';
 import { RelationsService } from '../relations.js';
 import { RevisionsService } from '../revisions.js';
-import { RolesService } from '../roles.js';
 import { ServerService } from '../server.js';
-import { SettingsService } from '../settings.js';
-import { SharesService } from '../shares.js';
 import { SpecificationService } from '../specifications.js';
 import { TFAService } from '../tfa.js';
 import { UsersService } from '../users.js';
 import { UtilsService } from '../utils.js';
-import { WebhooksService } from '../webhooks.js';
 import { GraphQLBigInt } from './types/bigint.js';
 import { GraphQLDate } from './types/date.js';
 import { GraphQLGeoJSON } from './types/geojson.js';
@@ -47,6 +36,9 @@ import { GraphQLStringOrFloat } from './types/string-or-float.js';
 import { GraphQLVoid } from './types/void.js';
 import { addPathToValidationError } from './utils/add-path-to-validation-error.js';
 import processError from './utils/process-error.js';
+import { createSubscriptionGenerator } from './subscription.js';
+import { getService } from '../../utils/get-service.js';
+import { toBoolean } from '../../utils/to-boolean.js';
 const validationRules = Array.from(specifiedRules);
 if (env['GRAPHQL_INTROSPECTION'] === false) {
     validationRules.push(NoSchemaIntrospectionCustomRule);
@@ -123,6 +115,14 @@ export class GraphQLService {
                 ? this.schema
                 : reduceSchema(this.schema, this.accountability?.permissions || null, ['delete']),
         };
+        const subscriptionEventType = schemaComposer.createEnumTC({
+            name: 'EventEnum',
+            values: {
+                create: { value: 'create' },
+                update: { value: 'update' },
+                delete: { value: 'delete' },
+            },
+        });
         const { ReadCollectionTypes } = getReadableTypes();
         const { CreateCollectionTypes, UpdateCollectionTypes, DeleteCollectionTypes } = getWritableTypes();
         const scopeFilter = (collection) => {
@@ -871,6 +871,26 @@ export class GraphQLService {
                         },
                     });
                 }
+                const eventName = `${collection.collection}_mutated`;
+                if (collection.collection in ReadCollectionTypes) {
+                    const subscriptionType = schemaComposer.createObjectTC({
+                        name: eventName,
+                        fields: {
+                            key: new GraphQLNonNull(GraphQLID),
+                            event: subscriptionEventType,
+                            data: ReadCollectionTypes[collection.collection],
+                        },
+                    });
+                    schemaComposer.Subscription.addFields({
+                        [eventName]: {
+                            type: subscriptionType,
+                            args: {
+                                event: subscriptionEventType,
+                            },
+                            subscribe: createSubscriptionGenerator(self, eventName),
+                        },
+                    });
+                }
             }
             for (const relation of schema.read.relations) {
                 if (relation.related_collection) {
@@ -1147,7 +1167,11 @@ export class GraphQLService {
         if (singleton && action === 'update') {
             return await this.upsertSingleton(collection, args['data'], query);
         }
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         const hasQuery = (query.fields || []).length > 0;
         try {
             if (single) {
@@ -1195,7 +1219,11 @@ export class GraphQLService {
      * Execute the read action on the correct service. Checks for singleton as well.
      */
     async read(collection, query) {
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         const result = this.schema.collections[collection].singleton
             ? await service.readSingleton(query, { stripNonRequested: false })
             : await service.readByQuery(query, { stripNonRequested: false });
@@ -1205,7 +1233,11 @@ export class GraphQLService {
      * Upsert and read singleton item
      */
     async upsertSingleton(collection, body, query) {
-        const service = this.getService(collection);
+        const service = getService(collection, {
+            knex: this.knex,
+            accountability: this.accountability,
+            schema: this.schema,
+        });
         try {
             await service.upsertSingleton(body);
             if ((query.fields || []).length > 0) {
@@ -1405,49 +1437,6 @@ export class GraphQLService {
         set(error, 'extensions.code', error.code);
         return new GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
     }
-    /**
-     * Select the correct service for the given collection. This allows the individual services to run
-     * their custom checks (f.e. it allows UsersService to prevent updating TFA secret from outside)
-     */
-    getService(collection) {
-        const opts = {
-            knex: this.knex,
-            accountability: this.accountability,
-            schema: this.schema,
-        };
-        switch (collection) {
-            case 'directus_activity':
-                return new ActivityService(opts);
-            case 'directus_files':
-                return new FilesService(opts);
-            case 'directus_folders':
-                return new FoldersService(opts);
-            case 'directus_permissions':
-                return new PermissionsService(opts);
-            case 'directus_presets':
-                return new PresetsService(opts);
-            case 'directus_notifications':
-                return new NotificationsService(opts);
-            case 'directus_revisions':
-                return new RevisionsService(opts);
-            case 'directus_roles':
-                return new RolesService(opts);
-            case 'directus_settings':
-                return new SettingsService(opts);
-            case 'directus_users':
-                return new UsersService(opts);
-            case 'directus_webhooks':
-                return new WebhooksService(opts);
-            case 'directus_shares':
-                return new SharesService(opts);
-            case 'directus_flows':
-                return new FlowsService(opts);
-            case 'directus_operations':
-                return new OperationsService(opts);
-            default:
-                return new ItemsService(collection, opts);
-        }
-    }
     /**
      * Replace all fragments in a selectionset for the actual selection set as defined in the fragment
      * Effectively merges the selections with the fragments used in those selections
@@ -1539,6 +1528,58 @@ export class GraphQLService {
                         },
                     }),
                 },
+                websocket: toBoolean(env['WEBSOCKETS_ENABLED'])
+                    ? {
+                        type: new GraphQLObjectType({
+                            name: 'server_info_websocket',
+                            fields: {
+                                rest: {
+                                    type: toBoolean(env['WEBSOCKETS_REST_ENABLED'])
+                                        ? new GraphQLObjectType({
+                                            name: 'server_info_websocket_rest',
+                                            fields: {
+                                                authentication: {
+                                                    type: new GraphQLEnumType({
+                                                        name: 'server_info_websocket_rest_authentication',
+                                                        values: {
+                                                            public: { value: 'public' },
+                                                            handshake: { value: 'handshake' },
+                                                            strict: { value: 'strict' },
+                                                        },
+                                                    }),
+                                                },
+                                                path: { type: GraphQLString },
+                                            },
+                                        })
+                                        : GraphQLBoolean,
+                                },
+                                graphql: {
+                                    type: toBoolean(env['WEBSOCKETS_GRAPHQL_ENABLED'])
+                                        ? new GraphQLObjectType({
+                                            name: 'server_info_websocket_graphql',
+                                            fields: {
+                                                authentication: {
+                                                    type: new GraphQLEnumType({
+                                                        name: 'server_info_websocket_graphql_authentication',
+                                                        values: {
+                                                            public: { value: 'public' },
+                                                            handshake: { value: 'handshake' },
+                                                            strict: { value: 'strict' },
+                                                        },
+                                                    }),
+                                                },
+                                                path: { type: GraphQLString },
+                                            },
+                                        })
+                                        : GraphQLBoolean,
+                                },
+                                heartbeat: {
+                                    type: toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED']) ? GraphQLInt : GraphQLBoolean,
+                                },
+                            },
+                        }),
+                    }
+                    : GraphQLBoolean,
                 queryLimit: {
                     type: new GraphQLObjectType({
                         name: 'server_info_query_limit',

package/dist/services/graphql/subscription.d.ts

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

package/dist/services/graphql/subscription.js

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

package/dist/services/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/websocket.d.ts

@@ -0,0 +1,14 @@
+import type { ActionHandler } from '@directus/types';
+import type { WebSocketClient } from '../websocket/types.js';
+import type { WebSocketMessage } from '../websocket/messages.js';
+export declare class WebSocketService {
+    private controller;
+    constructor();
+    on(event: 'connect' | 'message' | 'error' | 'close', callback: ActionHandler): void;
+    off(event: 'connect' | 'message' | 'error' | 'close', callback: ActionHandler): void;
+    broadcast(message: string | WebSocketMessage, filter?: {
+        user?: string;
+        role?: string;
+    }): void;
+    clients(): Set<WebSocketClient>;
+}