@directus/api 30.0.0 → 31.0.0

package/dist/mcp/tools/folders.js

@@ -0,0 +1,96 @@
+import { toArray } from '@directus/utils';
+import { z } from 'zod';
+import { FoldersService } from '../../services/folders.js';
+import { defineTool } from '../define.js';
+import { FolderItemInputSchema, FolderItemValidateSchema, PrimaryKeyInputSchema, PrimaryKeyValidateSchema, QueryInputSchema, QueryValidateSchema, } from '../schema.js';
+import prompts from './prompts/index.js';
+const FoldersValidateSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        action: z.literal('create'),
+        data: z.union([z.array(FolderItemValidateSchema), FolderItemValidateSchema]),
+        query: QueryValidateSchema.optional(),
+    }),
+    z.strictObject({
+        action: z.literal('read'),
+        keys: z.array(PrimaryKeyValidateSchema).optional(),
+        query: QueryValidateSchema.optional(),
+    }),
+    z.strictObject({
+        action: z.literal('update'),
+        data: FolderItemValidateSchema,
+        keys: z.array(PrimaryKeyValidateSchema).optional(),
+        query: QueryValidateSchema.optional(),
+    }),
+    z.strictObject({
+        action: z.literal('delete'),
+        keys: z.array(PrimaryKeyValidateSchema),
+    }),
+]);
+const FoldersInputSchema = z.object({
+    action: z.enum(['create', 'read', 'update', 'delete']).describe('The operation to perform'),
+    query: QueryInputSchema.optional(),
+    keys: z.array(PrimaryKeyInputSchema).optional(),
+    data: z.array(FolderItemInputSchema).optional(),
+});
+export const folders = defineTool({
+    name: 'folders',
+    description: prompts.folders,
+    annotations: {
+        title: 'Directus - Folders',
+    },
+    inputSchema: FoldersInputSchema,
+    validateSchema: FoldersValidateSchema,
+    async handler({ args, schema, accountability, sanitizedQuery }) {
+        const service = new FoldersService({
+            schema,
+            accountability,
+        });
+        if (args.action === 'create') {
+            const data = toArray(args.data);
+            const savedKeys = await service.createMany(data);
+            const result = await service.readMany(savedKeys, sanitizedQuery);
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'read') {
+            let result = null;
+            if (args.keys) {
+                result = await service.readMany(args.keys, sanitizedQuery);
+            }
+            else {
+                result = await service.readByQuery(sanitizedQuery);
+            }
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'update') {
+            let updatedKeys = [];
+            if (Array.isArray(args.data)) {
+                updatedKeys = await service.updateBatch(args.data);
+            }
+            else if (args.keys) {
+                updatedKeys = await service.updateMany(args.keys, args.data);
+            }
+            else {
+                updatedKeys = await service.updateByQuery(sanitizedQuery, args.data);
+            }
+            const result = await service.readMany(updatedKeys, sanitizedQuery);
+            return {
+                type: 'text',
+                data: result,
+            };
+        }
+        if (args.action === 'delete') {
+            const deletedKeys = await service.deleteMany(args.keys);
+            return {
+                type: 'text',
+                data: deletedKeys,
+            };
+        }
+        throw new Error('Invalid action.');
+    },
+});

package/dist/mcp/tools/index.d.ts

@@ -0,0 +1,15 @@
+import type { ToolConfig } from '../types.js';
+import { collections } from './collections.js';
+import { fields } from './fields.js';
+import { files } from './files.js';
+import { flows } from './flows.js';
+import { items } from './items.js';
+import { operations } from './operations.js';
+import { relations } from './relations.js';
+import { schema } from './schema.js';
+import { system } from './system.js';
+import { triggerFlow } from './trigger-flow.js';
+export declare const ALL_TOOLS: ToolConfig<any>[];
+export declare const getAllMcpTools: () => ToolConfig<any>[];
+export declare const findMcpTool: (name: string) => ToolConfig<any> | undefined;
+export { collections, fields, files, flows, items, operations, relations, schema, system, triggerFlow };

package/dist/mcp/tools/index.js

@@ -0,0 +1,29 @@
+import { assets } from './assets.js';
+import { collections } from './collections.js';
+import { fields } from './fields.js';
+import { files } from './files.js';
+import { flows } from './flows.js';
+import { folders } from './folders.js';
+import { items } from './items.js';
+import { operations } from './operations.js';
+import { relations } from './relations.js';
+import { schema } from './schema.js';
+import { system } from './system.js';
+import { triggerFlow } from './trigger-flow.js';
+export const ALL_TOOLS = [
+    system,
+    items,
+    files,
+    folders,
+    assets,
+    flows,
+    triggerFlow,
+    operations,
+    schema,
+    collections,
+    fields,
+    relations,
+];
+export const getAllMcpTools = () => ALL_TOOLS;
+export const findMcpTool = (name) => ALL_TOOLS.find((tool) => tool.name === name);
+export { collections, fields, files, flows, items, operations, relations, schema, system, triggerFlow };

package/dist/mcp/tools/items.d.ts

@@ -0,0 +1,87 @@
+export declare const items: import("../types.js").ToolConfig<{
+    collection: string;
+    action: "create";
+    data: Record<string, any> | Record<string, any>[];
+    query?: {
+        fields?: string[] | undefined;
+        sort?: string[] | undefined;
+        filter?: Record<string, any> | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        page?: number | undefined;
+        search?: string | undefined;
+        deep?: Record<string, any> | undefined;
+        alias?: Record<string, string> | undefined;
+        aggregate?: {
+            count: string[];
+            sum: string[];
+            avg: string[];
+            min: string[];
+            max: string[];
+        } | undefined;
+        backlink?: boolean | undefined;
+        version?: string | undefined;
+        versionRaw?: boolean | undefined;
+        export?: string | undefined;
+        group?: string[] | undefined;
+    } | undefined;
+} | {
+    collection: string;
+    action: "read";
+    keys?: (string | number)[] | undefined;
+    query?: {
+        fields?: string[] | undefined;
+        sort?: string[] | undefined;
+        filter?: Record<string, any> | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        page?: number | undefined;
+        search?: string | undefined;
+        deep?: Record<string, any> | undefined;
+        alias?: Record<string, string> | undefined;
+        aggregate?: {
+            count: string[];
+            sum: string[];
+            avg: string[];
+            min: string[];
+            max: string[];
+        } | undefined;
+        backlink?: boolean | undefined;
+        version?: string | undefined;
+        versionRaw?: boolean | undefined;
+        export?: string | undefined;
+        group?: string[] | undefined;
+    } | undefined;
+} | {
+    collection: string;
+    action: "update";
+    data: Record<string, any> | Record<string, any>[];
+    keys?: (string | number)[] | undefined;
+    query?: {
+        fields?: string[] | undefined;
+        sort?: string[] | undefined;
+        filter?: Record<string, any> | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        page?: number | undefined;
+        search?: string | undefined;
+        deep?: Record<string, any> | undefined;
+        alias?: Record<string, string> | undefined;
+        aggregate?: {
+            count: string[];
+            sum: string[];
+            avg: string[];
+            min: string[];
+            max: string[];
+        } | undefined;
+        backlink?: boolean | undefined;
+        version?: string | undefined;
+        versionRaw?: boolean | undefined;
+        export?: string | undefined;
+        group?: string[] | undefined;
+    } | undefined;
+} | {
+    collection: string;
+    action: "delete";
+    keys: (string | number)[];
+}>;

package/dist/mcp/tools/items.js

@@ -0,0 +1,141 @@
+import { ForbiddenError, InvalidPayloadError } from '@directus/errors';
+import { isSystemCollection } from '@directus/system-data';
+import { toArray } from '@directus/utils';
+import { isObject } from 'graphql-compose';
+import { z } from 'zod';
+import { ItemsService } from '../../services/items.js';
+import { defineTool } from '../define.js';
+import { ItemInputSchema, ItemValidateSchema, PrimaryKeyInputSchema, PrimaryKeyValidateSchema, QueryInputSchema, QueryValidateSchema, } from '../schema.js';
+import prompts from './prompts/index.js';
+const PartialItemInputSchema = z.strictObject({
+    collection: z.string(),
+});
+const ItemsValidateSchema = z.discriminatedUnion('action', [
+    PartialItemInputSchema.extend({
+        action: z.literal('create'),
+        data: z.union([z.array(ItemValidateSchema), ItemValidateSchema]),
+        query: QueryValidateSchema.optional(),
+    }),
+    PartialItemInputSchema.extend({
+        action: z.literal('read'),
+        keys: z.array(PrimaryKeyValidateSchema).optional(),
+        query: QueryValidateSchema.optional(),
+    }),
+    PartialItemInputSchema.extend({
+        action: z.literal('update'),
+        data: z.union([z.array(ItemValidateSchema), ItemValidateSchema]),
+        keys: z.array(PrimaryKeyValidateSchema).optional(),
+        query: QueryValidateSchema.optional(),
+    }),
+    PartialItemInputSchema.extend({
+        action: z.literal('delete'),
+        keys: z.array(PrimaryKeyValidateSchema),
+    }),
+]);
+const ItemsInputSchema = z.object({
+    action: z.enum(['create', 'read', 'update', 'delete']).describe('The operation to perform'),
+    collection: z.string().describe('The name of the collection'),
+    query: QueryInputSchema.optional(),
+    keys: z.array(PrimaryKeyInputSchema).optional(),
+    data: z.array(ItemInputSchema).optional(),
+});
+export const items = defineTool({
+    name: 'items',
+    description: prompts.items,
+    annotations: {
+        title: 'Directus - Items',
+    },
+    inputSchema: ItemsInputSchema,
+    validateSchema: ItemsValidateSchema,
+    endpoint({ input, data }) {
+        if (!isObject(data) || !('id' in data)) {
+            return;
+        }
+        return ['content', input.collection, data['id']];
+    },
+    async handler({ args, schema, accountability, sanitizedQuery }) {
+        if (isSystemCollection(args.collection)) {
+            throw new InvalidPayloadError({ reason: 'Cannot provide a core collection' });
+        }
+        if (args.collection in schema.collections === false) {
+            throw new ForbiddenError();
+        }
+        const isSingleton = schema.collections[args.collection]?.singleton ?? false;
+        const itemsService = new ItemsService(args.collection, {
+            schema,
+            accountability,
+        });
+        if (args.action === 'create') {
+            const data = toArray(args.data);
+            if (isSingleton) {
+                if (Array.isArray(args.data)) {
+                    throw new InvalidPayloadError({ reason: 'Invalid data payload, object exptected' });
+                }
+                await itemsService.upsertSingleton(args.data);
+                const item = await itemsService.readSingleton(sanitizedQuery);
+                return {
+                    type: 'text',
+                    data: item || null,
+                };
+            }
+            const savedKeys = await itemsService.createMany(data);
+            const result = await itemsService.readMany(savedKeys, sanitizedQuery);
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'read') {
+            let result = null;
+            if (isSingleton) {
+                result = await itemsService.readSingleton(sanitizedQuery);
+            }
+            else if (args.keys) {
+                result = await itemsService.readMany(args.keys, sanitizedQuery);
+            }
+            else {
+                result = await itemsService.readByQuery(sanitizedQuery);
+            }
+            return {
+                type: 'text',
+                data: result,
+            };
+        }
+        if (args.action === 'update') {
+            if (isSingleton) {
+                if (Array.isArray(args.data)) {
+                    throw new InvalidPayloadError({ reason: 'Invalid data payload, object exptected' });
+                }
+                await itemsService.upsertSingleton(args.data);
+                const item = await itemsService.readSingleton(sanitizedQuery);
+                return {
+                    type: 'text',
+                    data: item || null,
+                };
+            }
+            let updatedKeys = [];
+            if (Array.isArray(args.data)) {
+                updatedKeys = await itemsService.updateBatch(args.data);
+            }
+            else if (args.keys) {
+                updatedKeys = await itemsService.updateMany(args.keys, args.data);
+            }
+            else {
+                updatedKeys = await itemsService.updateByQuery(sanitizedQuery, args.data);
+            }
+            const result = await itemsService.readMany(updatedKeys, sanitizedQuery);
+            return {
+                type: 'text',
+                data: result,
+            };
+        }
+        if (args.action === 'delete') {
+            const deletedKeys = await itemsService.deleteMany(args.keys);
+            return {
+                type: 'text',
+                data: deletedKeys,
+            };
+        }
+        throw new Error('Invalid action.');
+    },
+});

package/dist/mcp/tools/operations.d.ts

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+export declare const OperationsValidationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    data: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        key: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        position_x: z.ZodOptional<z.ZodNumber>;
+        position_y: z.ZodOptional<z.ZodNumber>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        resolve: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        reject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        flow: z.ZodOptional<z.ZodString>;
+        date_created: z.ZodOptional<z.ZodString>;
+        user_created: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"read">;
+    query: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        page: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodString>;
+        deep: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        alias: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        aggregate: z.ZodOptional<z.ZodObject<{
+            count: z.ZodArray<z.ZodString>;
+            sum: z.ZodArray<z.ZodString>;
+            avg: z.ZodArray<z.ZodString>;
+            min: z.ZodArray<z.ZodString>;
+            max: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        backlink: z.ZodOptional<z.ZodBoolean>;
+        version: z.ZodOptional<z.ZodString>;
+        versionRaw: z.ZodOptional<z.ZodBoolean>;
+        export: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    data: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        key: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        position_x: z.ZodOptional<z.ZodNumber>;
+        position_y: z.ZodOptional<z.ZodNumber>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        resolve: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        reject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        flow: z.ZodOptional<z.ZodString>;
+        date_created: z.ZodOptional<z.ZodString>;
+        user_created: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    key: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    key: z.ZodString;
+}, z.core.$strict>]>;
+export declare const OperationsInputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        delete: "delete";
+        update: "update";
+        create: "create";
+        read: "read";
+    }>;
+    query: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        page: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodString>;
+        deep: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        alias: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        aggregate: z.ZodOptional<z.ZodObject<{
+            count: z.ZodArray<z.ZodString>;
+            sum: z.ZodArray<z.ZodString>;
+            avg: z.ZodArray<z.ZodString>;
+            min: z.ZodArray<z.ZodString>;
+            max: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        backlink: z.ZodOptional<z.ZodBoolean>;
+        version: z.ZodOptional<z.ZodString>;
+        versionRaw: z.ZodOptional<z.ZodBoolean>;
+        export: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    data: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        key: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        position_x: z.ZodOptional<z.ZodNumber>;
+        position_y: z.ZodOptional<z.ZodNumber>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        resolve: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        reject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+        flow: z.ZodOptional<z.ZodString>;
+        date_created: z.ZodOptional<z.ZodString>;
+        user_created: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    key: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const operations: import("../types.js").ToolConfig<{
+    action: "create";
+    data: {
+        id?: string | undefined;
+        name?: string | null | undefined;
+        key?: string | undefined;
+        type?: string | undefined;
+        position_x?: number | undefined;
+        position_y?: number | undefined;
+        options?: Record<string, any> | undefined;
+        resolve?: string | null | undefined;
+        reject?: string | null | undefined;
+        flow?: string | undefined;
+        date_created?: string | undefined;
+        user_created?: string | undefined;
+    };
+} | {
+    action: "read";
+    query?: {
+        fields?: string[] | undefined;
+        sort?: string[] | undefined;
+        filter?: Record<string, any> | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        page?: number | undefined;
+        search?: string | undefined;
+        deep?: Record<string, any> | undefined;
+        alias?: Record<string, string> | undefined;
+        aggregate?: {
+            count: string[];
+            sum: string[];
+            avg: string[];
+            min: string[];
+            max: string[];
+        } | undefined;
+        backlink?: boolean | undefined;
+        version?: string | undefined;
+        versionRaw?: boolean | undefined;
+        export?: string | undefined;
+        group?: string[] | undefined;
+    } | undefined;
+} | {
+    action: "update";
+    data: {
+        id?: string | undefined;
+        name?: string | null | undefined;
+        key?: string | undefined;
+        type?: string | undefined;
+        position_x?: number | undefined;
+        position_y?: number | undefined;
+        options?: Record<string, any> | undefined;
+        resolve?: string | null | undefined;
+        reject?: string | null | undefined;
+        flow?: string | undefined;
+        date_created?: string | undefined;
+        user_created?: string | undefined;
+    };
+    key: string;
+} | {
+    action: "delete";
+    key: string;
+}>;

package/dist/mcp/tools/operations.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { OperationsService } from '../../services/operations.js';
+import { defineTool } from '../define.js';
+import { OperationItemInputSchema, OperationItemValidateSchema, QueryInputSchema, QueryValidateSchema, } from '../schema.js';
+import prompts from './prompts/index.js';
+export const OperationsValidationSchema = z.discriminatedUnion('action', [
+    z.strictObject({
+        action: z.literal('create'),
+        data: OperationItemValidateSchema,
+    }),
+    z.strictObject({
+        action: z.literal('read'),
+        query: QueryValidateSchema.optional(),
+    }),
+    z.strictObject({
+        action: z.literal('update'),
+        data: OperationItemValidateSchema,
+        key: z.string(),
+    }),
+    z.strictObject({
+        action: z.literal('delete'),
+        key: z.string(),
+    }),
+]);
+export const OperationsInputSchema = z.object({
+    action: z.enum(['create', 'read', 'update', 'delete']).describe('The operation to perform'),
+    query: QueryInputSchema.optional(),
+    data: OperationItemInputSchema.optional(),
+    key: z.string().optional(),
+});
+export const operations = defineTool({
+    name: 'operations',
+    admin: true,
+    description: prompts.operations,
+    annotations: {
+        title: 'Directus - Operations',
+    },
+    inputSchema: OperationsInputSchema,
+    validateSchema: OperationsValidationSchema,
+    async handler({ args, schema, accountability, sanitizedQuery }) {
+        const operationService = new OperationsService({
+            schema,
+            accountability,
+        });
+        if (args.action === 'create') {
+            const savedKey = await operationService.createOne(args.data);
+            const result = await operationService.readOne(savedKey);
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'read') {
+            const result = await operationService.readByQuery(sanitizedQuery);
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'update') {
+            const updatedKey = await operationService.updateOne(args.key, args.data);
+            const result = await operationService.readOne(updatedKey, sanitizedQuery);
+            return {
+                type: 'text',
+                data: result || null,
+            };
+        }
+        if (args.action === 'delete') {
+            const deletedKey = await operationService.deleteOne(args.key);
+            return {
+                type: 'text',
+                data: deletedKey,
+            };
+        }
+        throw new Error('Invalid action.');
+    },
+});

package/dist/mcp/tools/prompts/assets.md

@@ -0,0 +1,8 @@
+Retrieve base64-encoded file content from Directus. Returns raw file data suitable for AI vision models, image analysis,
+and file operations.
+
+**Input**: `{"id": "file-uuid"}`
+
+**Output**: `{"data": "base64-string", "mimeType": "image/jpeg"}`
+
+**Note**: Supports images and audio files. Respects Directus permissions.