@directus/api 11.0.1 → 12.0.0

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

package/dist/websocket/types.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Accountability, Query } from '@directus/types';
+import type { IncomingMessage } from 'http';
+import type internal from 'stream';
+import type { WebSocket } from 'ws';
+export type AuthenticationState = {
+    accountability: Accountability | null;
+    expires_at: number | null;
+    refresh_token?: string;
+};
+export type WebSocketClient = WebSocket & AuthenticationState & {
+    uid: string | number;
+    auth_timer: NodeJS.Timer | null;
+};
+export type UpgradeRequest = IncomingMessage & AuthenticationState;
+export type SubscriptionEvent = 'create' | 'update' | 'delete';
+export type Subscription = {
+    uid?: string | number;
+    query?: Query;
+    item?: string | number;
+    event?: SubscriptionEvent;
+    collection: string;
+    client: WebSocketClient;
+};
+export type UpgradeContext = {
+    request: IncomingMessage;
+    socket: internal.Duplex;
+    head: Buffer;
+};
+export type GraphQLSocket = {
+    client: WebSocketClient;
+};

package/dist/websocket/types.js

@@ -0,0 +1 @@
+export {};

package/dist/websocket/utils/get-expires-at-for-token.d.ts

@@ -0,0 +1 @@
+export declare function getExpiresAtForToken(token: string): number | null;

package/dist/websocket/utils/get-expires-at-for-token.js

@@ -0,0 +1,8 @@
+import jwt from 'jsonwebtoken';
+export function getExpiresAtForToken(token) {
+    const decoded = jwt.decode(token);
+    if (decoded && typeof decoded === 'object' && decoded.exp) {
+        return decoded.exp;
+    }
+    return null;
+}

package/dist/websocket/utils/message.d.ts

@@ -0,0 +1,4 @@
+import type { WebSocketClient } from '../types.js';
+export declare const fmtMessage: (type: string, data?: Record<string, any>, uid?: string | number) => string;
+export declare const safeSend: (client: WebSocketClient, data: string, delay?: number) => Promise<unknown>;
+export declare const getMessageType: (message: any) => string;

package/dist/websocket/utils/message.js

@@ -0,0 +1,27 @@
+// a simple util for building a message object
+export const fmtMessage = (type, data = {}, uid) => {
+    const message = { type, ...data };
+    if (uid !== undefined) {
+        message['uid'] = uid;
+    }
+    return JSON.stringify(message);
+};
+// we may need this later for slow connections
+export const safeSend = async (client, data, delay = 100) => {
+    if (client.readyState !== client.OPEN)
+        return false;
+    if (client.bufferedAmount > 0) {
+        // wait for the buffer to clear
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                safeSend(client, data, delay).then((success) => resolve(success));
+            }, delay);
+        });
+    }
+    client.send(data);
+    return true;
+};
+// an often used message type extractor function
+export const getMessageType = (message) => {
+    return typeof message !== 'object' || Array.isArray(message) || message === null ? '' : String(message.type);
+};

package/dist/websocket/utils/wait-for-message.d.ts

@@ -0,0 +1,4 @@
+import type { WebSocket } from 'ws';
+import { WebSocketMessage } from '../messages.js';
+export declare const waitForAnyMessage: (client: WebSocket, timeout: number) => Promise<Record<string, any>>;
+export declare const waitForMessageType: (client: WebSocket, type: string, timeout: number) => Promise<WebSocketMessage>;

package/dist/websocket/utils/wait-for-message.js

@@ -0,0 +1,45 @@
+import { parseJSON } from '@directus/utils';
+import { WebSocketMessage } from '../messages.js';
+import { getMessageType } from './message.js';
+export const waitForAnyMessage = (client, timeout) => {
+    return new Promise((resolve, reject) => {
+        client.on('message', awaitMessage);
+        const timer = setTimeout(() => {
+            client.off('message', awaitMessage);
+            reject();
+        }, timeout);
+        function awaitMessage(event) {
+            try {
+                clearTimeout(timer);
+                client.off('message', awaitMessage);
+                resolve(parseJSON(event.toString()));
+            }
+            catch (err) {
+                reject(err);
+            }
+        }
+    });
+};
+export const waitForMessageType = (client, type, timeout) => {
+    return new Promise((resolve, reject) => {
+        client.on('message', awaitMessage);
+        const timer = setTimeout(() => {
+            client.off('message', awaitMessage);
+            reject();
+        }, timeout);
+        function awaitMessage(event) {
+            let msg;
+            try {
+                msg = WebSocketMessage.parse(parseJSON(event.toString()));
+            }
+            catch {
+                return;
+            }
+            if (getMessageType(msg) === type) {
+                clearTimeout(timer);
+                client.off('message', awaitMessage);
+                resolve(msg);
+            }
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "11.0.1",
+  "version": "12.0.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -92,6 +92,7 @@
     "fs-extra": "11.1.1",
     "graphql": "16.6.0",
     "graphql-compose": "9.0.10",
+    "graphql-ws": "5.12.0",
     "helmet": "7.0.0",
     "icc": "3.0.0",
     "inquirer": "9.2.4",
@@ -139,20 +140,24 @@
     "uuid-validate": "0.0.3",
     "vm2": "3.9.19",
     "wellknown": "0.5.0",
-    "@directus/app": "10.3.0",
-    "@directus/constants": "10.2.0",
-    "@directus/exceptions": "10.0.2",
-    "@directus/extensions-sdk": "10.1.3",
-    "@directus/pressure": "1.0.3",
+    "ws": "8.12.1",
+    "zod": "3.21.4",
+    "zod-validation-error": "1.0.1",
+    "@directus/app": "10.4.0",
+    "@directus/constants": "10.2.1",
+    "@directus/errors": "0.0.1",
+    "@directus/extensions-sdk": "10.1.5",
+    "@directus/pressure": "1.0.5",
     "@directus/schema": "10.0.1",
     "@directus/specs": "10.1.1",
-    "@directus/storage": "10.0.2",
-    "@directus/storage-driver-azure": "10.0.4",
-    "@directus/storage-driver-cloudinary": "10.0.4",
-    "@directus/storage-driver-gcs": "10.0.4",
-    "@directus/storage-driver-local": "10.0.4",
-    "@directus/storage-driver-s3": "10.0.4",
-    "@directus/utils": "10.0.4"
+    "@directus/storage": "10.0.4",
+    "@directus/storage-driver-azure": "10.0.6",
+    "@directus/storage-driver-cloudinary": "10.0.6",
+    "@directus/storage-driver-gcs": "10.0.6",
+    "@directus/storage-driver-local": "10.0.6",
+    "@directus/storage-driver-s3": "10.0.6",
+    "@directus/utils": "10.0.6",
+    "@directus/validation": "0.0.1"
   },
   "devDependencies": {
     "@ngneat/falso": "6.4.0",
@@ -191,6 +196,7 @@
     "@types/uuid": "9.0.1",
     "@types/uuid-validate": "0.0.1",
     "@types/wellknown": "0.5.4",
+    "@types/ws": "8.5.4",
     "@vitest/coverage-c8": "0.31.1",
     "copyfiles": "2.4.1",
     "form-data": "4.0.0",
@@ -198,13 +204,12 @@
     "supertest": "6.3.3",
     "typescript": "5.0.4",
     "vitest": "0.31.1",
+    "@directus/random": "0.2.1",
     "@directus/tsconfig": "0.0.7",
-    "@directus/types": "10.1.0"
+    "@directus/types": "10.1.2"
   },
   "optionalDependencies": {
     "@keyv/redis": "2.5.8",
-    "keyv-memcache": "1.3.3",
-    "memcached": "2.2.2",
     "mysql": "2.18.1",
     "nodemailer-mailgun-transport": "2.1.5",
     "nodemailer-sendgrid": "1.0.3",

package/dist/exceptions/content-too-large.d.ts

@@ -1,4 +0,0 @@
-import { BaseException } from '@directus/exceptions';
-export declare class ContentTooLargeException extends BaseException {
-    constructor(message: string);
-}

package/dist/exceptions/content-too-large.js

@@ -1,6 +0,0 @@
-import { BaseException } from '@directus/exceptions';
-export class ContentTooLargeException extends BaseException {
-    constructor(message) {
-        super(message, 413, 'CONTENT_TOO_LARGE');
-    }
-}

package/dist/exceptions/database/contains-null-values.d.ts

@@ -1,9 +0,0 @@
-import { BaseException } from '@directus/exceptions';
-type Exceptions = {
-    collection: string;
-    field: string;
-};
-export declare class ContainsNullValuesException extends BaseException {
-    constructor(field: string, exceptions?: Exceptions);
-}
-export {};

package/dist/exceptions/database/contains-null-values.js

@@ -1,6 +0,0 @@
-import { BaseException } from '@directus/exceptions';
-export class ContainsNullValuesException extends BaseException {
-    constructor(field, exceptions) {
-        super(`Field "${field}" contains null values.`, 400, 'CONTAINS_NULL_VALUES', exceptions);
-    }
-}

package/dist/exceptions/database/invalid-foreign-key.d.ts

@@ -1,10 +0,0 @@
-import { BaseException } from '@directus/exceptions';
-type Extensions = {
-    collection: string;
-    field: string;
-    invalid?: string;
-};
-export declare class InvalidForeignKeyException extends BaseException {
-    constructor(field: string | null, extensions?: Extensions);
-}
-export {};