@directus/api 11.0.1 → 12.0.0

package/dist/websocket/errors.js

@@ -0,0 +1,55 @@
+import { isDirectusError } from '@directus/errors';
+import { ZodError } from 'zod';
+import { fromZodError } from 'zod-validation-error';
+import logger from '../logger.js';
+export class WebSocketError extends Error {
+    type;
+    code;
+    uid;
+    constructor(type, code, message, uid) {
+        super(message);
+        this.type = type;
+        this.code = code;
+        this.uid = uid;
+    }
+    toJSON() {
+        const message = {
+            type: this.type,
+            status: 'error',
+            error: {
+                code: this.code,
+                message: this.message,
+            },
+        };
+        if (this.uid !== undefined) {
+            message.uid = this.uid;
+        }
+        return message;
+    }
+    toMessage() {
+        return JSON.stringify(this.toJSON());
+    }
+    static fromError(error, type = 'unknown') {
+        return new WebSocketError(type, error.code, error.message);
+    }
+    static fromZodError(error, type = 'unknown') {
+        const zError = fromZodError(error);
+        return new WebSocketError(type, 'INVALID_PAYLOAD', zError.message);
+    }
+}
+export function handleWebSocketError(client, error, type) {
+    if (isDirectusError(error)) {
+        client.send(WebSocketError.fromError(error, type).toMessage());
+        return;
+    }
+    if (error instanceof WebSocketError) {
+        client.send(error.toMessage());
+        return;
+    }
+    if (error instanceof ZodError) {
+        client.send(WebSocketError.fromZodError(error, type).toMessage());
+        return;
+    }
+    // unhandled exceptions
+    logger.error(`WebSocket unhandled exception ${JSON.stringify({ type, error })}`);
+}

package/dist/websocket/handlers/heartbeat.d.ts

@@ -0,0 +1,11 @@
+import { WebSocketController } from '../controllers/index.js';
+import { WebSocketMessage } from '../messages.js';
+import type { WebSocketClient } from '../types.js';
+export declare class HeartbeatHandler {
+    private pulse;
+    private controller;
+    constructor(controller?: WebSocketController);
+    private checkClients;
+    onMessage(client: WebSocketClient, message: WebSocketMessage): void;
+    pingClients(): void;
+}

package/dist/websocket/handlers/heartbeat.js

@@ -0,0 +1,72 @@
+import emitter from '../../emitter.js';
+import env from '../../env.js';
+import { toBoolean } from '../../utils/to-boolean.js';
+import { WebSocketController, getWebSocketController } from '../controllers/index.js';
+import { WebSocketMessage } from '../messages.js';
+import { fmtMessage, getMessageType } from '../utils/message.js';
+const HEARTBEAT_FREQUENCY = Number(env['WEBSOCKETS_HEARTBEAT_PERIOD']) * 1000;
+export class HeartbeatHandler {
+    pulse;
+    controller;
+    constructor(controller) {
+        this.controller = controller ?? getWebSocketController();
+        emitter.onAction('websocket.message', ({ client, message }) => {
+            try {
+                this.onMessage(client, WebSocketMessage.parse(message));
+            }
+            catch {
+                /* ignore errors */
+            }
+        });
+        if (toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED']) === true) {
+            emitter.onAction('websocket.connect', () => this.checkClients());
+            emitter.onAction('websocket.error', () => this.checkClients());
+            emitter.onAction('websocket.close', () => this.checkClients());
+        }
+    }
+    checkClients() {
+        const hasClients = this.controller.clients.size > 0;
+        if (hasClients && !this.pulse) {
+            this.pulse = setInterval(() => {
+                this.pingClients();
+            }, HEARTBEAT_FREQUENCY);
+        }
+        if (!hasClients && this.pulse) {
+            clearInterval(this.pulse);
+            this.pulse = undefined;
+        }
+    }
+    onMessage(client, message) {
+        if (getMessageType(message) !== 'ping')
+            return;
+        // send pong message back as acknowledgement
+        const data = 'uid' in message ? { uid: message.uid } : {};
+        client.send(fmtMessage('pong', data));
+    }
+    pingClients() {
+        const pendingClients = new Set(this.controller.clients);
+        const activeClients = new Set();
+        const timeout = setTimeout(() => {
+            // close connections that haven't responded
+            for (const client of pendingClients) {
+                client.close();
+            }
+        }, HEARTBEAT_FREQUENCY);
+        const messageWatcher = ({ client }) => {
+            // any message means this connection is still open
+            if (!activeClients.has(client)) {
+                pendingClients.delete(client);
+                activeClients.add(client);
+            }
+            if (pendingClients.size === 0) {
+                clearTimeout(timeout);
+                emitter.offAction('websocket.message', messageWatcher);
+            }
+        };
+        emitter.onAction('websocket.message', messageWatcher);
+        // ping all the clients
+        for (const client of pendingClients) {
+            client.send(fmtMessage('ping'));
+        }
+    }
+}

package/dist/websocket/handlers/index.d.ts

@@ -0,0 +1,4 @@
+export declare function startWebSocketHandlers(): void;
+export * from './heartbeat.js';
+export * from './items.js';
+export * from './subscribe.js';

package/dist/websocket/handlers/index.js

@@ -0,0 +1,11 @@
+import { HeartbeatHandler } from './heartbeat.js';
+import { ItemsHandler } from './items.js';
+import { SubscribeHandler } from './subscribe.js';
+export function startWebSocketHandlers() {
+    new HeartbeatHandler();
+    new ItemsHandler();
+    new SubscribeHandler();
+}
+export * from './heartbeat.js';
+export * from './items.js';
+export * from './subscribe.js';

package/dist/websocket/handlers/items.d.ts

@@ -0,0 +1,6 @@
+import { WebSocketItemsMessage } from '../messages.js';
+import type { WebSocketClient } from '../types.js';
+export declare class ItemsHandler {
+    constructor();
+    onMessage(client: WebSocketClient, message: WebSocketItemsMessage): Promise<void>;
+}

package/dist/websocket/handlers/items.js

@@ -0,0 +1,103 @@
+import emitter from '../../emitter.js';
+import { ItemsService, MetaService } from '../../services/index.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { WebSocketItemsMessage } from '../messages.js';
+import { fmtMessage, getMessageType } from '../utils/message.js';
+export class ItemsHandler {
+    constructor() {
+        emitter.onAction('websocket.message', ({ client, message }) => {
+            if (getMessageType(message) !== 'items')
+                return;
+            try {
+                const parsedMessage = WebSocketItemsMessage.parse(message);
+                this.onMessage(client, parsedMessage).catch((err) => {
+                    // this catch is required because the async onMessage function is not awaited
+                    handleWebSocketError(client, err, 'items');
+                });
+            }
+            catch (err) {
+                handleWebSocketError(client, err, 'items');
+            }
+        });
+    }
+    async onMessage(client, message) {
+        const uid = message.uid;
+        const accountability = client.accountability;
+        const schema = await getSchema();
+        if (!schema.collections[message.collection] || message.collection.startsWith('directus_')) {
+            throw new WebSocketError('items', 'INVALID_COLLECTION', 'The provided collection does not exists or is not accessible.', uid);
+        }
+        const isSingleton = !!schema.collections[message.collection]?.singleton;
+        const service = new ItemsService(message.collection, { schema, accountability });
+        const metaService = new MetaService({ schema, accountability });
+        let result, meta;
+        if (message.action === 'create') {
+            const query = sanitizeQuery(message?.query ?? {}, accountability);
+            if (Array.isArray(message.data)) {
+                const keys = await service.createMany(message.data);
+                result = await service.readMany(keys, query);
+            }
+            else {
+                const key = await service.createOne(message.data);
+                result = await service.readOne(key, query);
+            }
+        }
+        if (message.action === 'read') {
+            const query = sanitizeQuery(message.query ?? {}, accountability);
+            if (message.id) {
+                result = await service.readOne(message.id, query);
+            }
+            else if (message.ids) {
+                result = await service.readMany(message.ids, query);
+            }
+            else if (isSingleton) {
+                result = await service.readSingleton(query);
+            }
+            else {
+                result = await service.readByQuery(query);
+            }
+            meta = await metaService.getMetaForQuery(message.collection, query);
+        }
+        if (message.action === 'update') {
+            const query = sanitizeQuery(message.query ?? {}, accountability);
+            if (message.id) {
+                const key = await service.updateOne(message.id, message.data);
+                result = await service.readOne(key);
+            }
+            else if (message.ids) {
+                const keys = await service.updateMany(message.ids, message.data);
+                meta = await metaService.getMetaForQuery(message.collection, query);
+                result = await service.readMany(keys, query);
+            }
+            else if (isSingleton) {
+                await service.upsertSingleton(message.data);
+                result = await service.readSingleton(query);
+            }
+            else {
+                const keys = await service.updateByQuery(query, message.data);
+                meta = await metaService.getMetaForQuery(message.collection, query);
+                result = await service.readMany(keys, query);
+            }
+        }
+        if (message.action === 'delete') {
+            if (message.id) {
+                await service.deleteOne(message.id);
+                result = message.id;
+            }
+            else if (message.ids) {
+                await service.deleteMany(message.ids);
+                result = message.ids;
+            }
+            else if (message.query) {
+                const query = sanitizeQuery(message.query, accountability);
+                result = await service.deleteByQuery(query);
+            }
+            else {
+                throw new WebSocketError('items', 'INVALID_PAYLOAD', "Either 'ids', 'id' or 'query' is required for a DELETE request.", uid);
+            }
+        }
+        client.send(fmtMessage('items', { data: result, ...(meta ? { meta } : {}) }, uid));
+    }
+}

package/dist/websocket/handlers/subscribe.d.ts

@@ -0,0 +1,43 @@
+import type { Messenger } from '../../messenger.js';
+import type { WebSocketEvent } from '../messages.js';
+import { WebSocketSubscribeMessage } from '../messages.js';
+import type { Subscription, WebSocketClient } from '../types.js';
+/**
+ * Handler responsible for subscriptions
+ */
+export declare class SubscribeHandler {
+    subscriptions: Record<string, Set<Subscription>>;
+    protected messenger: Messenger;
+    /**
+     * Initialize the handler
+     */
+    constructor();
+    /**
+     * Hook into websocket client lifecycle events
+     */
+    bindWebSocket(): void;
+    /**
+     * Register a subscription
+     * @param subscription
+     */
+    subscribe(subscription: Subscription): void;
+    /**
+     * Remove a subscription
+     * @param subscription
+     */
+    unsubscribe(client: WebSocketClient, uid?: string | number): void;
+    /**
+     * Dispatch event to subscriptions
+     */
+    dispatch(event: WebSocketEvent): Promise<void>;
+    /**
+     * Handle incoming (un)subscribe requests
+     */
+    onMessage(client: WebSocketClient, message: WebSocketSubscribeMessage): Promise<void>;
+    private getSinglePayload;
+    private getMultiPayload;
+    private getCollectionPayload;
+    private getFieldsPayload;
+    private getItemsPayload;
+    private getSubscription;
+}

package/dist/websocket/handlers/subscribe.js

@@ -0,0 +1,278 @@
+import emitter from '../../emitter.js';
+import { InvalidPayloadError } from '../../errors/index.js';
+import { getMessenger } from '../../messenger.js';
+import { CollectionsService, FieldsService, MetaService } from '../../services/index.js';
+import { getSchema } from '../../utils/get-schema.js';
+import { getService } from '../../utils/get-service.js';
+import { sanitizeQuery } from '../../utils/sanitize-query.js';
+import { refreshAccountability } from '../authenticate.js';
+import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { WebSocketSubscribeMessage } from '../messages.js';
+import { fmtMessage, getMessageType } from '../utils/message.js';
+/**
+ * Handler responsible for subscriptions
+ */
+export class SubscribeHandler {
+    // storage of subscriptions per collection
+    subscriptions;
+    // internal message bus
+    messenger;
+    /**
+     * Initialize the handler
+     */
+    constructor() {
+        this.subscriptions = {};
+        this.messenger = getMessenger();
+        this.bindWebSocket();
+        // listen to the Redis pub/sub and dispatch
+        this.messenger.subscribe('websocket.event', (message) => {
+            try {
+                this.dispatch(message);
+            }
+            catch {
+                // don't error on an invalid event from the messenger
+            }
+        });
+    }
+    /**
+     * Hook into websocket client lifecycle events
+     */
+    bindWebSocket() {
+        // listen to incoming messages on the connected websockets
+        emitter.onAction('websocket.message', ({ client, message }) => {
+            if (!['subscribe', 'unsubscribe'].includes(getMessageType(message)))
+                return;
+            try {
+                this.onMessage(client, WebSocketSubscribeMessage.parse(message));
+            }
+            catch (error) {
+                handleWebSocketError(client, error, 'subscribe');
+            }
+        });
+        // unsubscribe when a connection drops
+        emitter.onAction('websocket.error', ({ client }) => this.unsubscribe(client));
+        emitter.onAction('websocket.close', ({ client }) => this.unsubscribe(client));
+    }
+    /**
+     * Register a subscription
+     * @param subscription
+     */
+    subscribe(subscription) {
+        const { collection } = subscription;
+        if ('item' in subscription && ['directus_fields', 'directus_relations'].includes(collection)) {
+            throw new InvalidPayloadError({ reason: `Cannot subscribe to a specific item in the ${collection} collection.` });
+        }
+        if (!this.subscriptions[collection]) {
+            this.subscriptions[collection] = new Set();
+        }
+        this.subscriptions[collection]?.add(subscription);
+    }
+    /**
+     * Remove a subscription
+     * @param subscription
+     */
+    unsubscribe(client, uid) {
+        if (uid !== undefined) {
+            const subscription = this.getSubscription(client, String(uid));
+            if (subscription) {
+                this.subscriptions[subscription.collection]?.delete(subscription);
+            }
+        }
+        else {
+            for (const key of Object.keys(this.subscriptions)) {
+                const subscriptions = Array.from(this.subscriptions[key] || []);
+                for (let i = subscriptions.length - 1; i >= 0; i--) {
+                    const subscription = subscriptions[i];
+                    if (!subscription)
+                        continue;
+                    if (subscription.client === client && (!uid || subscription.uid === uid)) {
+                        this.subscriptions[key]?.delete(subscription);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Dispatch event to subscriptions
+     */
+    async dispatch(event) {
+        const subscriptions = this.subscriptions[event.collection];
+        if (!subscriptions || subscriptions.size === 0)
+            return;
+        const schema = await getSchema();
+        for (const subscription of subscriptions) {
+            const { client } = subscription;
+            if (subscription.event !== undefined && event.action !== subscription.event) {
+                continue; // skip filtered events
+            }
+            try {
+                client.accountability = await refreshAccountability(client.accountability);
+                const result = 'item' in subscription
+                    ? await this.getSinglePayload(subscription, client.accountability, schema, event)
+                    : await this.getMultiPayload(subscription, client.accountability, schema, event);
+                if (Array.isArray(result?.['data']) && result?.['data']?.length === 0)
+                    return;
+                client.send(fmtMessage('subscription', result, subscription.uid));
+            }
+            catch (err) {
+                handleWebSocketError(client, err, 'subscribe');
+            }
+        }
+    }
+    /**
+     * Handle incoming (un)subscribe requests
+     */
+    async onMessage(client, message) {
+        if (getMessageType(message) === 'subscribe') {
+            try {
+                const collection = String(message.collection);
+                const accountability = client.accountability;
+                const schema = await getSchema();
+                if (!accountability?.admin && !schema.collections[collection]) {
+                    throw new WebSocketError('subscribe', 'INVALID_COLLECTION', 'The provided collection does not exists or is not accessible.', message.uid);
+                }
+                const subscription = {
+                    client,
+                    collection,
+                };
+                if ('event' in message) {
+                    subscription.event = message.event;
+                }
+                if ('query' in message) {
+                    subscription.query = sanitizeQuery(message.query, accountability);
+                }
+                if ('item' in message)
+                    subscription.item = String(message.item);
+                if ('uid' in message) {
+                    subscription.uid = String(message.uid);
+                    // remove the subscription if it already exists
+                    this.unsubscribe(client, subscription.uid);
+                }
+                let data;
+                if (subscription.event === undefined) {
+                    data =
+                        'item' in subscription
+                            ? await this.getSinglePayload(subscription, accountability, schema)
+                            : await this.getMultiPayload(subscription, accountability, schema);
+                }
+                else {
+                    data = { event: 'init' };
+                }
+                // if no errors were thrown register the subscription
+                this.subscribe(subscription);
+                // send an initial response
+                client.send(fmtMessage('subscription', data, subscription.uid));
+            }
+            catch (err) {
+                handleWebSocketError(client, err, 'subscribe');
+            }
+        }
+        if (getMessageType(message) === 'unsubscribe') {
+            try {
+                this.unsubscribe(client, message.uid);
+                client.send(fmtMessage('subscription', { event: 'unsubscribe' }, message.uid));
+            }
+            catch (err) {
+                handleWebSocketError(client, err, 'unsubscribe');
+            }
+        }
+    }
+    async getSinglePayload(subscription, accountability, schema, event) {
+        const metaService = new MetaService({ schema, accountability });
+        const query = subscription.query ?? {};
+        const id = subscription.item;
+        const result = {
+            event: event?.action ?? 'init',
+        };
+        if (subscription.collection === 'directus_collections') {
+            const service = new CollectionsService({ schema, accountability });
+            result['data'] = await service.readOne(String(id));
+        }
+        else {
+            const service = getService(subscription.collection, { schema, accountability });
+            result['data'] = await service.readOne(id, query);
+        }
+        if ('meta' in query) {
+            result['meta'] = await metaService.getMetaForQuery(subscription.collection, query);
+        }
+        return result;
+    }
+    async getMultiPayload(subscription, accountability, schema, event) {
+        const metaService = new MetaService({ schema, accountability });
+        const result = {
+            event: event?.action ?? 'init',
+        };
+        switch (subscription.collection) {
+            case 'directus_collections':
+                result['data'] = await this.getCollectionPayload(accountability, schema, event);
+                break;
+            case 'directus_fields':
+                result['data'] = await this.getFieldsPayload(accountability, schema, event);
+                break;
+            case 'directus_relations':
+                result['data'] = event?.payload;
+                break;
+            default:
+                result['data'] = await this.getItemsPayload(subscription, accountability, schema, event);
+                break;
+        }
+        const query = subscription.query ?? {};
+        if ('meta' in query) {
+            result['meta'] = await metaService.getMetaForQuery(subscription.collection, query);
+        }
+        return result;
+    }
+    async getCollectionPayload(accountability, schema, event) {
+        const service = new CollectionsService({ schema, accountability });
+        if (!event?.action) {
+            return await service.readByQuery();
+        }
+        else if (event.action === 'create') {
+            return await service.readMany([String(event.key)]);
+        }
+        else if (event.action === 'delete') {
+            return event.keys;
+        }
+        else {
+            return await service.readMany(event.keys.map((key) => String(key)));
+        }
+    }
+    async getFieldsPayload(accountability, schema, event) {
+        const service = new FieldsService({ schema, accountability });
+        if (!event?.action) {
+            return await service.readAll();
+        }
+        else if (event.action === 'delete') {
+            return event.keys;
+        }
+        else {
+            return await service.readOne(event.payload?.['collection'], event.payload?.['field']);
+        }
+    }
+    async getItemsPayload(subscription, accountability, schema, event) {
+        const query = subscription.query ?? {};
+        const service = getService(subscription.collection, { schema, accountability });
+        if (!event?.action) {
+            return await service.readByQuery(query);
+        }
+        else if (event.action === 'create') {
+            return await service.readMany([event.key], query);
+        }
+        else if (event.action === 'delete') {
+            return event.keys;
+        }
+        else {
+            return await service.readMany(event.keys, query);
+        }
+    }
+    getSubscription(client, uid) {
+        for (const userSubscriptions of Object.values(this.subscriptions)) {
+            for (const subscription of userSubscriptions) {
+                if (subscription.client === client && subscription.uid === uid) {
+                    return subscription;
+                }
+            }
+        }
+        return undefined;
+    }
+}