@directus/api 32.2.0 → 33.1.0

package/dist/websocket/collab/verify-permissions.js

@@ -0,0 +1,100 @@
+import { useLogger } from '../../logger/index.js';
+import { fetchPermissions } from '../../permissions/lib/fetch-permissions.js';
+import { fetchPolicies } from '../../permissions/lib/fetch-policies.js';
+import { fetchAllowedFields } from '../../permissions/modules/fetch-allowed-fields/fetch-allowed-fields.js';
+import { validateItemAccess } from '../../permissions/modules/validate-access/lib/validate-item-access.js';
+import { extractRequiredDynamicVariableContextForPermissions } from '../../permissions/utils/extract-required-dynamic-variable-context.js';
+import { fetchDynamicVariableData } from '../../permissions/utils/fetch-dynamic-variable-data.js';
+import { processPermissions } from '../../permissions/utils/process-permissions.js';
+import { getService } from '../../utils/get-service.js';
+import { calculateCacheMetadata } from './calculate-cache-metadata.js';
+import { filterToFields } from './filter-to-fields.js';
+import { permissionCache } from './permissions-cache.js';
+/**
+ * Verify if a client has permissions to perform an action on the item.
+ * - `string[]`: List of fields the client has access to, empty if item exists but access is restricted.
+ * - `null`: Indicates the item doesn't exist.
+ */
+export async function verifyPermissions(accountability, collection, item, action = 'read', options) {
+    if (!accountability)
+        return [];
+    const { schema, knex } = options;
+    if (!schema.collections[collection])
+        return [];
+    if (accountability.admin)
+        return ['*'];
+    const cached = permissionCache.get(accountability, collection, String(item), action);
+    if (cached !== undefined)
+        return cached;
+    // Prevent caching stale permissions if invalidation occurs during async steps
+    const startInvalidationCount = permissionCache.getInvalidationCount();
+    let itemData = null;
+    try {
+        const adminService = getService(collection, { schema, knex });
+        const policies = await fetchPolicies(accountability, { knex, schema });
+        const rawPermissions = await fetchPermissions({ action, collections: [collection], policies, accountability, bypassDynamicVariableProcessing: true }, { knex, schema });
+        // Check for item-level rules to skip DB fetch
+        const hasItemRules = rawPermissions.some((p) => p.permissions && Object.keys(p.permissions).length > 0);
+        if (hasItemRules) {
+            // Resolve dynamic variables used in the permission filters
+            const dynamicVariableContext = extractRequiredDynamicVariableContextForPermissions(rawPermissions);
+            const permissionsContext = await fetchDynamicVariableData({ accountability, policies, dynamicVariableContext }, { knex, schema });
+            const processedPermissions = processPermissions({
+                permissions: rawPermissions,
+                accountability,
+                permissionsContext,
+            });
+            const fieldsToFetch = processedPermissions
+                .map((perm) => (perm.permissions ? filterToFields(perm.permissions, collection, schema) : []))
+                .flat();
+            // Fetch current item data to evaluate any conditional permission filters based on record state
+            if (item && action !== 'create') {
+                try {
+                    itemData = await adminService.readOne(item, {
+                        fields: fieldsToFetch,
+                    });
+                }
+                catch {
+                    // Item doesn't exist
+                    permissionCache.set(accountability, collection, String(item), action, null, []);
+                    return null;
+                }
+            }
+            else if (schema.collections[collection]?.singleton && action !== 'create') {
+                const pkField = schema.collections[collection].primary;
+                if (pkField) {
+                    if (Array.from(fieldsToFetch).some((field) => field === '*' || field === pkField) === false) {
+                        fieldsToFetch.push(pkField);
+                    }
+                }
+                itemData = await adminService.readSingleton({ fields: fieldsToFetch });
+            }
+        }
+        let allowedFields = [];
+        if ((item || schema.collections[collection]?.singleton) && hasItemRules) {
+            const primaryKeys = item ? [item] : [];
+            const validationContext = {
+                collection,
+                accountability,
+                action,
+                primaryKeys,
+                returnAllowedRootFields: true,
+            };
+            allowedFields = (await validateItemAccess(validationContext, { knex, schema })).allowedRootFields || [];
+        }
+        else {
+            allowedFields = await fetchAllowedFields({ accountability, action, collection }, { knex, schema });
+        }
+        // Only cache if the state hasn't been invalidated by another operation in the meantime
+        if (permissionCache.getInvalidationCount() === startInvalidationCount) {
+            // Determine TTL and relational dependencies for cache invalidation
+            const { ttlMs, dependencies } = calculateCacheMetadata(collection, itemData, rawPermissions, schema, accountability);
+            permissionCache.set(accountability, collection, String(item), action, allowedFields, dependencies, ttlMs);
+        }
+        return allowedFields;
+    }
+    catch (err) {
+        useLogger().error(err, `[Collab] verifyPermissions failed for user "${accountability.user}", collection "${collection}", and item "${item}"`);
+        return [];
+    }
+}

package/dist/websocket/controllers/base.d.ts

@@ -1,8 +1,8 @@
+import type { Server as httpServer, IncomingMessage } from 'http';
+import type internal from 'stream';
 import type { Accountability } from '@directus/types';
 import { WebSocketMessage } from '@directus/types';
-import type { IncomingMessage, Server as httpServer } from 'http';
 import type { RateLimiterAbstract } from 'rate-limiter-flexible';
-import type internal from 'stream';
 import WebSocket, { type Server } from 'ws';
 import { WebSocketAuthMessage } from '../messages.js';
 import type { AuthenticationState, UpgradeContext, WebSocketAuthentication, WebSocketClient } from '../types.js';

package/dist/websocket/controllers/base.js

@@ -1,10 +1,10 @@
+import { randomUUID } from 'node:crypto';
+import { parse } from 'url';
 import { useEnv } from '@directus/env';
 import { InvalidProviderConfigError, TokenExpiredError } from '@directus/errors';
 import { WebSocketMessage } from '@directus/types';
 import { parseJSON, toBoolean } from '@directus/utils';
 import cookie from 'cookie';
-import { randomUUID } from 'node:crypto';
-import { parse } from 'url';
 import WebSocket, { WebSocketServer } from 'ws';
 import { fromZodError } from 'zod-validation-error';
 import emitter from '../../emitter.js';
@@ -13,7 +13,7 @@ import { createDefaultAccountability } from '../../permissions/utils/create-defa
 import { createRateLimiter } from '../../rate-limiter.js';
 import { getIPFromReq } from '../../utils/get-ip-from-req.js';
 import { authenticateConnection, authenticationSuccess } from '../authenticate.js';
-import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { handleWebSocketError, WebSocketError } from '../errors.js';
 import { AuthMode, WebSocketAuthMessage } from '../messages.js';
 import { getMessageType } from '../utils/message.js';
 import { waitForAnyMessage, waitForMessageType } from '../utils/wait-for-message.js';

package/dist/websocket/controllers/graphql.d.ts

@@ -1,5 +1,5 @@
-import type { Server } from 'graphql-ws';
 import type { Server as httpServer } from 'http';
+import type { Server } from 'graphql-ws';
 import type { GraphQLSocket, UpgradeContext, WebSocketClient } from '../types.js';
 import SocketController from './base.js';
 export declare class GraphQLSubscriptionController extends SocketController {

package/dist/websocket/controllers/graphql.js

@@ -1,4 +1,4 @@
-import { CloseCode, MessageType, makeServer } from 'graphql-ws';
+import { CloseCode, makeServer, MessageType } from 'graphql-ws';
 import { useLogger } from '../../logger/index.js';
 import { createDefaultAccountability } from '../../permissions/utils/create-default-accountability.js';
 import { bindPubSub } from '../../services/graphql/subscription.js';

package/dist/websocket/controllers/logs.d.ts

@@ -1,7 +1,7 @@
 import type { Server as httpServer } from 'http';
+import type { Accountability } from '@directus/types';
 import { AuthMode } from '../messages.js';
 import SocketController from './base.js';
-import type { Accountability } from '@directus/types';
 export declare class LogsController extends SocketController {
     constructor(httpServer: httpServer);
     getEnvironmentConfig(configPrefix: string): {

package/dist/websocket/controllers/rest.d.ts

@@ -1,5 +1,5 @@
-import { WebSocketMessage } from '@directus/types';
 import type { Server as httpServer } from 'http';
+import { WebSocketMessage } from '@directus/types';
 import SocketController from './base.js';
 export declare class WebSocketController extends SocketController {
     constructor(httpServer: httpServer);

package/dist/websocket/controllers/rest.js

@@ -1,9 +1,9 @@
-import { parseJSON } from '@directus/utils';
 import { WebSocketMessage } from '@directus/types';
+import { parseJSON } from '@directus/utils';
 import emitter from '../../emitter.js';
 import { useLogger } from '../../logger/index.js';
 import { getAddress } from '../../utils/get-address.js';
-import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { handleWebSocketError, WebSocketError } from '../errors.js';
 import SocketController from './base.js';
 import { registerWebSocketEvents } from './hooks.js';
 const logger = useLogger();

package/dist/websocket/handlers/heartbeat.js

@@ -3,7 +3,7 @@ import { ServiceUnavailableError } from '@directus/errors';
 import { WebSocketMessage } from '@directus/types';
 import { toBoolean } from '@directus/utils';
 import emitter from '../../emitter.js';
-import { WebSocketController, getWebSocketController } from '../controllers/index.js';
+import { getWebSocketController, WebSocketController } from '../controllers/index.js';
 import { fmtMessage, getMessageType } from '../utils/message.js';
 const env = useEnv();
 const HEARTBEAT_FREQUENCY = Number(env['WEBSOCKETS_HEARTBEAT_PERIOD']) * 1000;

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

@@ -1,4 +1,6 @@
+import { CollabHandler } from '../collab/collab.js';
 export declare function startWebSocketHandlers(): void;
+export declare function getCollabHandler(): CollabHandler | undefined;
 export * from './heartbeat.js';
 export * from './items.js';
 export * from './logs.js';

package/dist/websocket/handlers/index.js

@@ -1,15 +1,18 @@
 import { useEnv } from '@directus/env';
 import { toBoolean } from '@directus/utils';
+import { CollabHandler } from '../collab/collab.js';
 import { HeartbeatHandler } from './heartbeat.js';
 import { ItemsHandler } from './items.js';
 import { LogsHandler } from './logs.js';
 import { SubscribeHandler } from './subscribe.js';
+let collabHandler;
 export function startWebSocketHandlers() {
     const env = useEnv();
     const heartbeatEnabled = toBoolean(env['WEBSOCKETS_HEARTBEAT_ENABLED']);
     const restEnabled = toBoolean(env['WEBSOCKETS_REST_ENABLED']);
     const graphqlEnabled = toBoolean(env['WEBSOCKETS_GRAPHQL_ENABLED']);
     const logsEnabled = toBoolean(env['WEBSOCKETS_LOGS_ENABLED']);
+    const collabEnabled = toBoolean(env['WEBSOCKETS_COLLAB_ENABLED']);
     if (restEnabled && heartbeatEnabled) {
         new HeartbeatHandler();
     }
@@ -22,6 +25,12 @@ export function startWebSocketHandlers() {
     if (logsEnabled) {
         new LogsHandler();
     }
+    if (collabEnabled) {
+        collabHandler = new CollabHandler();
+    }
+}
+export function getCollabHandler() {
+    return collabHandler;
 }
 export * from './heartbeat.js';
 export * from './items.js';

package/dist/websocket/handlers/items.js

@@ -1,9 +1,9 @@
+import { isSystemCollection } from '@directus/system-data';
 import emitter from '../../emitter.js';
 import { ItemsService, MetaService } from '../../services/index.js';
 import { getSchema } from '../../utils/get-schema.js';
-import { isSystemCollection } from '@directus/system-data';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
-import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { handleWebSocketError, WebSocketError } from '../errors.js';
 import { WebSocketItemsMessage } from '../messages.js';
 import { fmtMessage, getMessageType } from '../utils/message.js';
 export class ItemsHandler {

package/dist/websocket/handlers/subscribe.js

@@ -4,7 +4,7 @@ import { useBus } from '../../bus/index.js';
 import emitter from '../../emitter.js';
 import { getSchema } from '../../utils/get-schema.js';
 import { sanitizeQuery } from '../../utils/sanitize-query.js';
-import { WebSocketError, handleWebSocketError } from '../errors.js';
+import { handleWebSocketError, WebSocketError } from '../errors.js';
 import { WebSocketSubscribeMessage } from '../messages.js';
 import { getPayload } from '../utils/items.js';
 import { fmtMessage, getMessageType } from '../utils/message.js';

package/dist/websocket/types.d.ts

@@ -1,6 +1,6 @@
-import type { Accountability, Query } from '@directus/types';
 import type { IncomingMessage } from 'http';
 import type internal from 'stream';
+import type { Accountability, Query } from '@directus/types';
 import type { WebSocket } from 'ws';
 import type { AuthMode } from './messages.js';
 export type AuthenticationState = {

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

@@ -20,7 +20,7 @@ export declare function getPayload(subscription: PSubscription, accountability:
  * @param event Event data
  * @returns the fetched collection data
  */
-export declare function getCollectionPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | import("../../types/collection.js").Collection | (string | number)[] | import("../../types/collection.js").Collection[]>;
+export declare function getCollectionPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | (string | number)[] | import("../../types/collection.js").Collection | import("../../types/collection.js").Collection[]>;
 /**
  * Get fields items
  *
@@ -29,7 +29,7 @@ export declare function getCollectionPayload(subscription: PSubscription, accoun
  * @param event Event data
  * @returns the fetched field data
  */
-export declare function getFieldsPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | Record<string, any> | import("@directus/types").Field[] | (string | number)[]>;
+export declare function getFieldsPayload(subscription: PSubscription, accountability: Accountability | null, schema: SchemaOverview, event?: WebSocketEvent): Promise<string | number | Record<string, any> | (string | number)[] | import("@directus/types").Field[]>;
 /**
  * Get items from a collection using the appropriate service
  *

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

@@ -1,4 +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;
+export declare function getMessageType(message: unknown): string;

package/dist/websocket/utils/message.js

@@ -22,6 +22,6 @@ export const safeSend = async (client, data, delay = 100) => {
     return true;
 };
 // an often used message type extractor function
-export const getMessageType = (message) => {
+export function getMessageType(message) {
     return typeof message !== 'object' || Array.isArray(message) || message === null ? '' : String(message.type);
-};
+}

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

@@ -1,5 +1,5 @@
-import { parseJSON } from '@directus/utils';
 import { WebSocketMessage } from '@directus/types';
+import { parseJSON } from '@directus/utils';
 import { getMessageType } from './message.js';
 export const waitForAnyMessage = (client, timeout) => {
     return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directus/api",
-  "version": "32.2.0",
+  "version": "33.1.0",
   "description": "Directus is a real-time API and App dashboard for managing SQL database content",
   "keywords": [
     "directus",
@@ -58,19 +58,21 @@
     "dist"
   ],
   "dependencies": {
-    "@ai-sdk/anthropic": "3.0.0-beta.53",
-    "@ai-sdk/openai": "3.0.0-beta.57",
+    "@ai-sdk/anthropic": "3.0.9",
+    "@ai-sdk/google": "3.0.6",
+    "@ai-sdk/openai": "3.0.7",
+    "@ai-sdk/openai-compatible": "2.0.4",
     "@authenio/samlify-node-xmllint": "2.0.0",
     "@aws-sdk/client-sesv2": "3.928.0",
     "@godaddy/terminus": "4.12.1",
-    "@modelcontextprotocol/sdk": "1.24.0",
+    "@modelcontextprotocol/sdk": "1.26.0",
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-node-resolve": "16.0.3",
     "@rollup/plugin-virtual": "3.0.2",
     "@tus/server": "2.3.0",
     "@tus/utils": "0.6.0",
+    "ai": "6.0.25",
     "archiver": "7.0.1",
-    "ai": "6.0.0-beta.98",
     "argon2": "0.44.0",
     "async": "3.2.6",
     "async-mutex": "0.5.0",
@@ -114,7 +116,7 @@
     "jsonwebtoken": "9.0.3",
     "keyv": "5.5.3",
     "knex": "3.1.0",
-    "ldapjs": "2.3.3",
+    "ldapts": "8.1.3",
     "liquidjs": "10.24.0",
     "lodash-es": "4.17.21",
     "marked": "16.4.1",
@@ -125,7 +127,7 @@
     "ms": "2.1.3",
     "nanoid": "5.1.6",
     "node-machine-id": "1.1.12",
-    "nodemailer": "7.0.10",
+    "nodemailer": "7.0.11",
     "object-hash": "3.0.0",
     "openapi3-ts": "4.5.0",
     "openid-client": "5.7.1",
@@ -138,10 +140,10 @@
     "pino-http": "10.5.0",
     "pino-http-print": "3.1.0",
     "pino-pretty": "13.1.2",
-    "pm2": "6.0.13",
+    "pm2": "6.0.14",
     "prom-client": "15.1.3",
     "proxy-addr": "2.0.7",
-    "qs": "6.14.0",
+    "qs": "6.14.1",
     "rate-limiter-flexible": "7.2.0",
     "rolldown": "1.0.0-beta.31",
     "rollup": "4.52.5",
@@ -151,37 +153,38 @@
     "sharp": "0.34.5",
     "snappy": "7.3.3",
     "stream-json": "1.9.1",
-    "tar": "7.5.2",
+    "tar": "7.5.4",
     "tsx": "4.20.6",
     "uuid": "11.1.0",
     "wellknown": "0.5.0",
     "ws": "8.18.3",
     "zod": "4.1.12",
     "zod-validation-error": "4.0.2",
-    "@directus/app": "14.4.0",
-    "@directus/extensions": "3.0.15",
-    "@directus/errors": "2.1.0",
-    "@directus/extensions-sdk": "17.0.4",
+    "@directus/ai": "1.1.0",
+    "@directus/app": "15.1.0",
+    "@directus/env": "5.5.0",
+    "@directus/extensions": "3.0.17",
     "@directus/constants": "14.0.0",
-    "@directus/extensions-registry": "3.0.15",
-    "@directus/env": "5.3.3",
+    "@directus/errors": "2.2.0",
+    "@directus/extensions-registry": "3.0.17",
+    "@directus/memory": "3.1.0",
     "@directus/format-title": "12.1.1",
-    "@directus/memory": "3.0.13",
-    "@directus/pressure": "3.0.13",
-    "@directus/schema": "13.0.4",
+    "@directus/pressure": "3.0.15",
+    "@directus/schema": "13.0.5",
+    "@directus/extensions-sdk": "17.0.6",
+    "@directus/schema-builder": "0.0.12",
+    "@directus/specs": "12.0.0",
     "@directus/storage": "12.0.3",
-    "@directus/specs": "11.2.0",
-    "@directus/schema-builder": "0.0.10",
-    "@directus/storage-driver-azure": "12.0.13",
-    "@directus/storage-driver-cloudinary": "12.0.13",
-    "@directus/storage-driver-gcs": "12.0.13",
+    "@directus/storage-driver-azure": "12.0.15",
+    "@directus/storage-driver-s3": "12.1.1",
+    "@directus/storage-driver-gcs": "12.0.15",
     "@directus/storage-driver-local": "12.0.3",
-    "@directus/system-data": "3.5.0",
-    "@directus/storage-driver-supabase": "3.0.13",
-    "@directus/utils": "13.1.0",
-    "@directus/validation": "2.0.13",
-    "@directus/storage-driver-s3": "12.0.13",
-    "directus": "11.14.0"
+    "@directus/storage-driver-supabase": "3.0.15",
+    "@directus/system-data": "4.1.0",
+    "@directus/utils": "13.2.0",
+    "directus": "11.15.0",
+    "@directus/validation": "2.0.15",
+    "@directus/storage-driver-cloudinary": "12.0.15"
   },
   "devDependencies": {
     "@directus/tsconfig": "3.0.0",
@@ -204,7 +207,6 @@
     "@types/js-yaml": "4.0.9",
     "@types/json2csv": "5.0.7",
     "@types/jsonwebtoken": "9.0.10",
-    "@types/ldapjs": "2.2.5",
     "@types/lodash-es": "4.17.12",
     "@types/mime-types": "3.0.1",
     "@types/ms": "2.1.0",
@@ -225,8 +227,8 @@
     "knex-mock-client": "3.0.2",
     "typescript": "5.9.3",
     "vitest": "3.2.4",
-    "@directus/schema-builder": "0.0.10",
-    "@directus/types": "13.5.0"
+    "@directus/schema-builder": "0.0.12",
+    "@directus/types": "14.1.0"
   },
   "optionalDependencies": {
     "@keyv/redis": "3.0.1",

package/dist/controllers/webhooks.js

@@ -1,74 +0,0 @@
-import { ErrorCode, createError } from '@directus/errors';
-import express from 'express';
-import { respond } from '../middleware/respond.js';
-import useCollection from '../middleware/use-collection.js';
-import { validateBatch } from '../middleware/validate-batch.js';
-import { MetaService } from '../services/meta.js';
-import { WebhooksService } from '../services/webhooks.js';
-import asyncHandler from '../utils/async-handler.js';
-import { sanitizeQuery } from '../utils/sanitize-query.js';
-const router = express.Router();
-router.use(useCollection('directus_webhooks'));
-router.post('/', asyncHandler(async (_req, _res, _next) => {
-    // Disallow creation of new Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-const readHandler = asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const metaService = new MetaService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const records = await service.readByQuery(req.sanitizedQuery);
-    const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
-    res.locals['payload'] = { data: records || null, meta };
-    return next();
-});
-router.get('/', validateBatch('read'), readHandler, respond);
-router.search('/', validateBatch('read'), readHandler, respond);
-router.get('/:pk', asyncHandler(async (req, res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    const record = await service.readOne(req.params['pk'], req.sanitizedQuery);
-    res.locals['payload'] = { data: record || null };
-    return next();
-}), respond);
-router.patch('/', validateBatch('update'), asyncHandler(async (_req, _res, _next) => {
-    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-router.patch('/:pk', asyncHandler(async (_req, _res, _next) => {
-    // Disallow patching of Webhooks as part of the deprecation, see https://github.com/directus/directus/issues/15553
-    throw new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-}), respond);
-router.delete('/', asyncHandler(async (req, _res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    if (Array.isArray(req.body)) {
-        await service.deleteMany(req.body);
-    }
-    else if (req.body.keys) {
-        await service.deleteMany(req.body.keys);
-    }
-    else {
-        const sanitizedQuery = await sanitizeQuery(req.body.query, req.schema, req.accountability);
-        await service.deleteByQuery(sanitizedQuery);
-    }
-    return next();
-}), respond);
-router.delete('/:pk', asyncHandler(async (req, _res, next) => {
-    const service = new WebhooksService({
-        accountability: req.accountability,
-        schema: req.schema,
-    });
-    await service.deleteOne(req.params['pk']);
-    return next();
-}), respond);
-export default router;

package/dist/services/webhooks.d.ts

@@ -1,14 +0,0 @@
-import { type DirectusError } from '@directus/errors';
-import type { Bus } from '@directus/memory';
-import type { AbstractServiceOptions, MutationOptions, PrimaryKey, Webhook } from '@directus/types';
-import { ItemsService } from './items.js';
-export declare class WebhooksService extends ItemsService<Webhook> {
-    messenger: Bus;
-    errorDeprecation: DirectusError;
-    constructor(options: AbstractServiceOptions);
-    createOne(): Promise<PrimaryKey>;
-    createMany(): Promise<PrimaryKey[]>;
-    updateBatch(): Promise<PrimaryKey[]>;
-    updateMany(): Promise<PrimaryKey[]>;
-    deleteMany(keys: PrimaryKey[], opts?: MutationOptions): Promise<PrimaryKey[]>;
-}

package/dist/services/webhooks.js

@@ -1,32 +0,0 @@
-import { ErrorCode, createError } from '@directus/errors';
-import { useBus } from '../bus/index.js';
-import { useLogger } from '../logger/index.js';
-import { ItemsService } from './items.js';
-const logger = useLogger();
-export class WebhooksService extends ItemsService {
-    messenger;
-    errorDeprecation;
-    constructor(options) {
-        super('directus_webhooks', options);
-        this.messenger = useBus();
-        this.errorDeprecation = new (createError(ErrorCode.MethodNotAllowed, 'Webhooks are deprecated, use Flows instead', 405))();
-        logger.warn('Webhooks are deprecated and the WebhooksService will be removed in an upcoming release. Creating/Updating Webhooks is disabled, use Flows instead');
-    }
-    async createOne() {
-        throw this.errorDeprecation;
-    }
-    async createMany() {
-        throw this.errorDeprecation;
-    }
-    async updateBatch() {
-        throw this.errorDeprecation;
-    }
-    async updateMany() {
-        throw this.errorDeprecation;
-    }
-    async deleteMany(keys, opts) {
-        const result = await super.deleteMany(keys, opts);
-        this.messenger.publish('webhooks', { type: 'reload' });
-        return result;
-    }
-}

package/dist/utils/get-relation-info.d.ts

@@ -1,6 +0,0 @@
-import type { Relation } from '@directus/types';
-export type RelationInfo = {
-    relation: Relation | null;
-    relationType: 'o2m' | 'm2o' | 'a2o' | 'o2a' | null;
-};
-export declare function getRelationInfo(relations: Relation[], collection: string, field: string): RelationInfo;

package/dist/utils/get-relation-info.js

@@ -1,43 +0,0 @@
-import { getRelation } from '@directus/utils';
-import { getRelationType } from './get-relation-type.js';
-function checkImplicitRelation(field) {
-    if (field.startsWith('$FOLLOW(') && field.endsWith(')')) {
-        return field.slice(8, -1).split(',');
-    }
-    return null;
-}
-export function getRelationInfo(relations, collection, field) {
-    if (field.startsWith('$FOLLOW') && field.length > 500) {
-        throw new Error(`Implicit $FOLLOW statement is too big to parse. Got: "${field.substring(500)}..."`);
-    }
-    const implicitRelation = checkImplicitRelation(field);
-    if (implicitRelation) {
-        if (implicitRelation[2] === undefined) {
-            const [m2oCollection, m2oField] = implicitRelation;
-            const relation = {
-                collection: m2oCollection.trim(),
-                field: m2oField.trim(),
-                related_collection: collection,
-                schema: null,
-                meta: null,
-            };
-            return { relation, relationType: 'o2m' };
-        }
-        else {
-            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
-            const relation = {
-                collection: a2oCollection.trim(),
-                field: a2oItemField.trim(),
-                related_collection: collection,
-                schema: null,
-                meta: {
-                    one_collection_field: a2oCollectionField.trim(),
-                },
-            };
-            return { relation, relationType: 'o2a' };
-        }
-    }
-    const relation = getRelation(relations, collection, field) ?? null;
-    const relationType = relation ? getRelationType({ relation, collection, field }) : null;
-    return { relation, relationType };
-}

package/dist/utils/get-relation-type.d.ts

@@ -1,6 +0,0 @@
-import type { Relation } from '@directus/types';
-export declare function getRelationType(getRelationOptions: {
-    relation?: Relation | null;
-    collection: string | null;
-    field: string;
-}): 'm2o' | 'o2m' | 'a2o' | null;