@directus/api 11.0.0 → 11.1.0

package/dist/websocket/handlers/subscribe.js

@@ -0,0 +1,278 @@
+import emitter from '../../emitter.js';
+import { InvalidPayloadException } from '../../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 { WebSocketException, handleWebSocketException } from '../exceptions.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) {
+                handleWebSocketException(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 InvalidPayloadException(`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) {
+                handleWebSocketException(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 WebSocketException('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) {
+                handleWebSocketException(client, err, 'subscribe');
+            }
+        }
+        if (getMessageType(message) === 'unsubscribe') {
+            try {
+                this.unsubscribe(client, message.uid);
+                client.send(fmtMessage('subscription', { event: 'unsubscribe' }, message.uid));
+            }
+            catch (err) {
+                handleWebSocketException(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;
+    }
+}

package/dist/websocket/messages.d.ts

@@ -0,0 +1,311 @@
+import type { Item, Query } from '@directus/types';
+import { z } from 'zod';
+export declare const WebSocketMessage: z.ZodObject<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type WebSocketMessage = z.infer<typeof WebSocketMessage>;
+export declare const WebSocketResponse: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"ok">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"ok">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"ok">;
+}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">>]>;
+export type WebSocketResponse = z.infer<typeof WebSocketResponse>;
+export declare const ConnectionParams: z.ZodObject<{
+    access_token: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    access_token?: string | undefined;
+}, {
+    access_token?: string | undefined;
+}>;
+export type ConnectionParams = z.infer<typeof ConnectionParams>;
+export declare const BasicAuthMessage: z.ZodUnion<[z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>, z.ZodObject<{
+    access_token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+}, {
+    access_token: string;
+}>, z.ZodObject<{
+    refresh_token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refresh_token: string;
+}, {
+    refresh_token: string;
+}>]>;
+export type BasicAuthMessage = z.infer<typeof BasicAuthMessage>;
+export declare const WebSocketAuthMessage: z.ZodIntersection<z.ZodObject<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"auth">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"auth">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"auth">;
+}, z.ZodTypeAny, "passthrough">>, z.ZodUnion<[z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>, z.ZodObject<{
+    access_token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    access_token: string;
+}, {
+    access_token: string;
+}>, z.ZodObject<{
+    refresh_token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refresh_token: string;
+}, {
+    refresh_token: string;
+}>]>>;
+export type WebSocketAuthMessage = z.infer<typeof WebSocketAuthMessage>;
+export declare const WebSocketSubscribeMessage: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"subscribe">;
+    collection: z.ZodString;
+    event: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"create">, z.ZodLiteral<"update">, z.ZodLiteral<"delete">]>>;
+    item: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"subscribe">;
+    collection: z.ZodString;
+    event: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"create">, z.ZodLiteral<"update">, z.ZodLiteral<"delete">]>>;
+    item: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"subscribe">;
+    collection: z.ZodString;
+    event: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"create">, z.ZodLiteral<"update">, z.ZodLiteral<"delete">]>>;
+    item: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"unsubscribe">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"unsubscribe">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"unsubscribe">;
+}, z.ZodTypeAny, "passthrough">>]>;
+export type WebSocketSubscribeMessage = z.infer<typeof WebSocketSubscribeMessage>;
+export declare const WebSocketItemsMessage: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"items">;
+    collection: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    action: z.ZodLiteral<"create">;
+    data: z.ZodUnion<[z.ZodArray<z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>, "many">, z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>]>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, "strip", z.ZodTypeAny, {
+    type: "items";
+    action: "create";
+    data: (Partial<Item> | Partial<Item>[]) & (Partial<Item> | Partial<Item>[] | undefined);
+    collection: string;
+    uid?: string | number | undefined;
+    query?: Query | undefined;
+}, {
+    type: "items";
+    action: "create";
+    data: (Partial<Item> | Partial<Item>[]) & (Partial<Item> | Partial<Item>[] | undefined);
+    collection: string;
+    uid?: string | number | undefined;
+    query?: Query | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"items">;
+    collection: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    action: z.ZodLiteral<"read">;
+    ids: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, "strip", z.ZodTypeAny, {
+    type: "items";
+    action: "read";
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}, {
+    type: "items";
+    action: "read";
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"items">;
+    collection: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    action: z.ZodLiteral<"update">;
+    data: z.ZodType<Partial<Item>, z.ZodTypeDef, Partial<Item>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, "strip", z.ZodTypeAny, {
+    type: "items";
+    action: "update";
+    data: Partial<Item>;
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}, {
+    type: "items";
+    action: "update";
+    data: Partial<Item>;
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"items">;
+    collection: z.ZodString;
+    uid: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    action: z.ZodLiteral<"delete">;
+    ids: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">>;
+    id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    query: z.ZodOptional<z.ZodType<Query, z.ZodTypeDef, Query>>;
+}, "strip", z.ZodTypeAny, {
+    type: "items";
+    action: "delete";
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}, {
+    type: "items";
+    action: "delete";
+    collection: string;
+    uid?: string | number | undefined;
+    ids?: (string | number)[] | undefined;
+    id?: string | number | undefined;
+    query?: Query | undefined;
+}>]>;
+export type WebSocketItemsMessage = z.infer<typeof WebSocketItemsMessage>;
+export declare const WebSocketEvent: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    key: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}, "strip", z.ZodTypeAny, {
+    key: string | number;
+    action: "create";
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}, {
+    key: string | number;
+    action: "create";
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    keys: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "update";
+    keys: (string | number)[];
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}, {
+    action: "update";
+    keys: (string | number)[];
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    keys: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    action: "delete";
+    keys: (string | number)[];
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}, {
+    action: "delete";
+    keys: (string | number)[];
+    collection: string;
+    payload?: Record<string, any> | undefined;
+}>]>;
+export type WebSocketEvent = z.infer<typeof WebSocketEvent>;
+export declare const AuthMode: z.ZodUnion<[z.ZodLiteral<"public">, z.ZodLiteral<"handshake">, z.ZodLiteral<"strict">]>;
+export type AuthMode = z.infer<typeof AuthMode>;

package/dist/websocket/messages.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+const zodStringOrNumber = z.union([z.string(), z.number()]);
+export const WebSocketMessage = z
+    .object({
+    type: z.string(),
+    uid: zodStringOrNumber.optional(),
+})
+    .passthrough();
+export const WebSocketResponse = z.discriminatedUnion('status', [
+    WebSocketMessage.extend({
+        status: z.literal('ok'),
+    }),
+    WebSocketMessage.extend({
+        status: z.literal('error'),
+        error: z
+            .object({
+            code: z.string(),
+            message: z.string(),
+        })
+            .passthrough(),
+    }),
+]);
+export const ConnectionParams = z.object({ access_token: z.string().optional() });
+export const BasicAuthMessage = z.union([
+    z.object({ email: z.string().email(), password: z.string() }),
+    z.object({ access_token: z.string() }),
+    z.object({ refresh_token: z.string() }),
+]);
+export const WebSocketAuthMessage = WebSocketMessage.extend({
+    type: z.literal('auth'),
+}).and(BasicAuthMessage);
+export const WebSocketSubscribeMessage = z.discriminatedUnion('type', [
+    WebSocketMessage.extend({
+        type: z.literal('subscribe'),
+        collection: z.string(),
+        event: z.union([z.literal('create'), z.literal('update'), z.literal('delete')]).optional(),
+        item: zodStringOrNumber.optional(),
+        query: z.custom().optional(),
+    }),
+    WebSocketMessage.extend({
+        type: z.literal('unsubscribe'),
+    }),
+]);
+const ZodItem = z.custom();
+const PartialItemsMessage = z.object({
+    uid: zodStringOrNumber.optional(),
+    type: z.literal('items'),
+    collection: z.string(),
+});
+export const WebSocketItemsMessage = z.union([
+    PartialItemsMessage.extend({
+        action: z.literal('create'),
+        data: z.union([z.array(ZodItem), ZodItem]),
+        query: z.custom().optional(),
+    }),
+    PartialItemsMessage.extend({
+        action: z.literal('read'),
+        ids: z.array(zodStringOrNumber).optional(),
+        id: zodStringOrNumber.optional(),
+        query: z.custom().optional(),
+    }),
+    PartialItemsMessage.extend({
+        action: z.literal('update'),
+        data: ZodItem,
+        ids: z.array(zodStringOrNumber).optional(),
+        id: zodStringOrNumber.optional(),
+        query: z.custom().optional(),
+    }),
+    PartialItemsMessage.extend({
+        action: z.literal('delete'),
+        ids: z.array(zodStringOrNumber).optional(),
+        id: zodStringOrNumber.optional(),
+        query: z.custom().optional(),
+    }),
+]);
+export const WebSocketEvent = z.discriminatedUnion('action', [
+    z.object({
+        action: z.literal('create'),
+        collection: z.string(),
+        payload: z.record(z.any()).optional(),
+        key: zodStringOrNumber,
+    }),
+    z.object({
+        action: z.literal('update'),
+        collection: z.string(),
+        payload: z.record(z.any()).optional(),
+        keys: z.array(zodStringOrNumber),
+    }),
+    z.object({
+        action: z.literal('delete'),
+        collection: z.string(),
+        payload: z.record(z.any()).optional(),
+        keys: z.array(zodStringOrNumber),
+    }),
+]);
+export const AuthMode = z.union([z.literal('public'), z.literal('handshake'), z.literal('strict')]);