@payloadcms/plugin-mcp 0.0.1-alpha.0

package/src/mcp/tools/resource/delete.ts

@@ -0,0 +1,210 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest, TypedUser } from 'payload'
+
+import type { PluginMCPServerConfig } from '../../../types.js'
+
+import { toCamelCase } from '../../../utils/camelCase.js'
+import { toolSchemas } from '../schemas.js'
+
+export const deleteResourceTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  user: TypedUser,
+  verboseLogs: boolean,
+  collectionSlug: string,
+  collections: PluginMCPServerConfig['collections'],
+) => {
+  const tool = async (
+    id?: string,
+    where?: string,
+    depth: number = 0,
+  ): Promise<{
+    content: Array<{
+      text: string
+      type: 'text'
+    }>
+  }> => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Deleting resource from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ' with where clause'}`,
+      )
+    }
+
+    try {
+      // Validate that either id or where is provided
+      if (!id && !where) {
+        payload.logger.error('[payload-mcp] Either id or where clause must be provided')
+        const response = {
+          content: [
+            { type: 'text' as const, text: 'Error: Either id or where clause must be provided' },
+          ],
+        }
+        return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+          response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      }
+
+      // Parse where clause if provided
+      let whereClause = {}
+      if (where) {
+        try {
+          whereClause = JSON.parse(where)
+          if (verboseLogs) {
+            payload.logger.info(`[payload-mcp] Using where clause: ${where}`)
+          }
+        } catch (_parseError) {
+          payload.logger.warn(`[payload-mcp] Invalid where clause JSON: ${where}`)
+          const response = {
+            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in where clause' }],
+          }
+          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+            response) as {
+            content: Array<{
+              text: string
+              type: 'text'
+            }>
+          }
+        }
+      }
+
+      // Build delete options
+      const deleteOptions: Record<string, unknown> = {
+        collection: collectionSlug,
+        depth,
+        user,
+      }
+
+      // Delete by ID or where clause
+      if (id) {
+        deleteOptions.id = id
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Deleting single document with ID: ${id}`)
+        }
+      } else {
+        deleteOptions.where = whereClause
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Deleting multiple documents with where clause`)
+        }
+      }
+
+      const result = await payload.delete(deleteOptions as Parameters<typeof payload.delete>[0])
+
+      // Handle different result types
+      if (id) {
+        // Single document deletion
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Successfully deleted document with ID: ${id}`)
+        }
+
+        const response = {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Document deleted successfully from collection "${collectionSlug}"!
+Deleted document:
+\`\`\`json
+${JSON.stringify(result, null, 2)}
+\`\`\``,
+            },
+          ],
+        }
+
+        return (collections?.[collectionSlug]?.overrideResponse?.(response, result, req) ||
+          response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      } else {
+        // Multiple documents deletion
+        const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
+        const docs = bulkResult.docs || []
+        const errors = bulkResult.errors || []
+
+        if (verboseLogs) {
+          payload.logger.info(
+            `[payload-mcp] Successfully deleted ${docs.length} documents, ${errors.length} errors`,
+          )
+        }
+
+        let responseText = `Document deleted successfully from collection "${collectionSlug}"!
+Deleted: ${docs.length} documents
+Errors: ${errors.length}
+---`
+
+        if (docs.length > 0) {
+          responseText += `\n\nDeleted documents:
+\`\`\`json
+${JSON.stringify(docs, null, 2)}
+\`\`\``
+        }
+
+        if (errors.length > 0) {
+          responseText += `\n\nErrors:
+\`\`\`json
+${JSON.stringify(errors, null, 2)}
+\`\`\``
+        }
+
+        const response = {
+          content: [
+            {
+              type: 'text' as const,
+              text: responseText,
+            },
+          ],
+        }
+
+        return (collections?.[collectionSlug]?.overrideResponse?.(
+          response,
+          { docs, errors },
+          req,
+        ) || response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error deleting resource from ${collectionSlug}: ${errorMessage}`,
+      )
+
+      const response = {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error deleting resource from collection "${collectionSlug}": ${errorMessage}`,
+          },
+        ],
+      }
+
+      return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) || response) as {
+        content: Array<{
+          text: string
+          type: 'text'
+        }>
+      }
+    }
+  }
+
+  if (collections?.[collectionSlug]?.enabled) {
+    server.tool(
+      `delete${collectionSlug.charAt(0).toUpperCase() + toCamelCase(collectionSlug).slice(1)}`,
+      `${toolSchemas.deleteResource.description.trim()}\n\n${collections?.[collectionSlug]?.description || ''}`,
+      toolSchemas.deleteResource.parameters.shape,
+      async ({ id, depth, where }) => {
+        return await tool(id, where, depth)
+      },
+    )
+  }
+}

package/src/mcp/tools/resource/find.ts

@@ -0,0 +1,194 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { PayloadRequest, TypedUser } from 'payload'
+
+import type { PluginMCPServerConfig } from '../../../types.js'
+
+import { toCamelCase } from '../../../utils/camelCase.js'
+import { toolSchemas } from '../schemas.js'
+
+export const findResourceTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  user: TypedUser,
+  verboseLogs: boolean,
+  collectionSlug: string,
+  collections: PluginMCPServerConfig['collections'],
+) => {
+  const tool = async (
+    id?: string,
+    limit: number = 10,
+    page: number = 1,
+    sort?: string,
+    where?: string,
+  ): Promise<{
+    content: Array<{
+      text: string
+      type: 'text'
+    }>
+  }> => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Reading resource from collection: ${collectionSlug}${id ? ` with ID: ${id}` : ''}, limit: ${limit}, page: ${page}`,
+      )
+    }
+
+    try {
+      // Parse where clause if provided
+      let whereClause = {}
+      if (where) {
+        try {
+          whereClause = JSON.parse(where)
+          if (verboseLogs) {
+            payload.logger.info(`[payload-mcp] Using where clause: ${where}`)
+          }
+        } catch (_parseError) {
+          payload.logger.warn(`[payload-mcp] Invalid where clause JSON: ${where}`)
+          const response = {
+            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in where clause' }],
+          }
+          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+            response) as {
+            content: Array<{
+              text: string
+              type: 'text'
+            }>
+          }
+        }
+      }
+
+      // If ID is provided, use findByID
+      if (id) {
+        try {
+          const doc = await payload.findByID({
+            id,
+            collection: collectionSlug,
+            user,
+          })
+
+          if (verboseLogs) {
+            payload.logger.info(`[payload-mcp] Found document with ID: ${id}`)
+          }
+
+          const response = {
+            content: [
+              {
+                type: 'text' as const,
+                text: `Resource from collection "${collectionSlug}":
+${JSON.stringify(doc, null, 2)}`,
+              },
+            ],
+          }
+
+          return (collections?.[collectionSlug]?.overrideResponse?.(response, doc, req) ||
+            response) as {
+            content: Array<{
+              text: string
+              type: 'text'
+            }>
+          }
+        } catch (_findError) {
+          payload.logger.warn(
+            `[payload-mcp] Document not found with ID: ${id} in collection: ${collectionSlug}`,
+          )
+          const response = {
+            content: [
+              {
+                type: 'text' as const,
+                text: `Error: Document with ID "${id}" not found in collection "${collectionSlug}"`,
+              },
+            ],
+          }
+          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+            response) as {
+            content: Array<{
+              text: string
+              type: 'text'
+            }>
+          }
+        }
+      }
+
+      // Otherwise, use find to get multiple documents
+      const findOptions: Parameters<typeof payload.find>[0] = {
+        collection: collectionSlug,
+        limit,
+        page,
+        user,
+      }
+
+      if (sort) {
+        findOptions.sort = sort
+      }
+
+      if (Object.keys(whereClause).length > 0) {
+        findOptions.where = whereClause
+      }
+
+      const result = await payload.find(findOptions)
+
+      if (verboseLogs) {
+        payload.logger.info(
+          `[payload-mcp] Found ${result.docs.length} documents in collection: ${collectionSlug}`,
+        )
+      }
+
+      let responseText = `Collection: "${collectionSlug}"
+Total: ${result.totalDocs} documents
+Page: ${result.page} of ${result.totalPages}
+`
+
+      for (const doc of result.docs) {
+        responseText += `\n\`\`\`json\n${JSON.stringify(doc, null, 2)}\n\`\`\``
+      }
+
+      const response = {
+        content: [
+          {
+            type: 'text' as const,
+            text: responseText,
+          },
+        ],
+      }
+
+      return (collections?.[collectionSlug]?.overrideResponse?.(response, result, req) ||
+        response) as {
+        content: Array<{
+          text: string
+          type: 'text'
+        }>
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error reading resources from collection ${collectionSlug}: ${errorMessage}`,
+      )
+      const response = {
+        content: [
+          {
+            type: 'text' as const,
+            text: `❌ **Error reading resources from collection "${collectionSlug}":** ${errorMessage}`,
+          },
+        ],
+      }
+      return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) || response) as {
+        content: Array<{
+          text: string
+          type: 'text'
+        }>
+      }
+    }
+  }
+
+  if (collections?.[collectionSlug]?.enabled) {
+    server.tool(
+      `find${collectionSlug.charAt(0).toUpperCase() + toCamelCase(collectionSlug).slice(1)}`,
+      `${toolSchemas.findResources.description.trim()}\n\n${collections?.[collectionSlug]?.description || ''}`,
+      toolSchemas.findResources.parameters.shape,
+      async ({ id, limit, page, sort, where }) => {
+        return await tool(id, limit, page, sort, where)
+      },
+    )
+  }
+}

package/src/mcp/tools/resource/update.ts

@@ -0,0 +1,314 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { JSONSchema4 } from 'json-schema'
+import type { PayloadRequest, TypedUser } from 'payload'
+
+import { z } from 'zod'
+
+import type { PluginMCPServerConfig } from '../../../types.js'
+
+import { toCamelCase } from '../../../utils/camelCase.js'
+import { convertCollectionSchemaToZod } from '../../../utils/convertCollectionSchemaToZod.js'
+import { toolSchemas } from '../schemas.js'
+export const updateResourceTool = (
+  server: McpServer,
+  req: PayloadRequest,
+  user: TypedUser,
+  verboseLogs: boolean,
+  collectionSlug: string,
+  collections: PluginMCPServerConfig['collections'],
+  schema: JSONSchema4,
+) => {
+  const tool = async (
+    data: string,
+    id?: string,
+    where?: string,
+    draft: boolean = false,
+    depth: number = 0,
+    overrideLock: boolean = true,
+    filePath?: string,
+    overwriteExistingFiles: boolean = false,
+  ): Promise<{
+    content: Array<{
+      text: string
+      type: 'text'
+    }>
+  }> => {
+    const payload = req.payload
+
+    if (verboseLogs) {
+      payload.logger.info(
+        `[payload-mcp] Updating resource in collection: ${collectionSlug}${id ? ` with ID: ${id}` : ' with where clause'}, draft: ${draft}`,
+      )
+    }
+
+    try {
+      // Parse the data JSON
+      let parsedData: Record<string, unknown>
+      try {
+        parsedData = JSON.parse(data)
+        if (verboseLogs) {
+          payload.logger.info(
+            `[payload-mcp] Parsed data for ${collectionSlug}: ${JSON.stringify(parsedData)}`,
+          )
+        }
+      } catch (_parseError) {
+        payload.logger.error(`[payload-mcp] Invalid JSON data provided: ${data}`)
+        const response = {
+          content: [{ type: 'text' as const, text: 'Error: Invalid JSON data provided' }],
+        }
+        return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+          response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      }
+
+      // Validate that either id or where is provided
+      if (!id && !where) {
+        payload.logger.error('[payload-mcp] Either id or where clause must be provided')
+        const response = {
+          content: [
+            { type: 'text' as const, text: 'Error: Either id or where clause must be provided' },
+          ],
+        }
+        return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+          response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      }
+
+      // Parse where clause if provided
+      let whereClause = {}
+      if (where) {
+        try {
+          whereClause = JSON.parse(where)
+          if (verboseLogs) {
+            payload.logger.info(`[payload-mcp] Using where clause: ${where}`)
+          }
+        } catch (_parseError) {
+          payload.logger.error(`[payload-mcp] Invalid where clause JSON: ${where}`)
+          const response = {
+            content: [{ type: 'text' as const, text: 'Error: Invalid JSON in where clause' }],
+          }
+          return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) ||
+            response) as {
+            content: Array<{
+              text: string
+              type: 'text'
+            }>
+          }
+        }
+      }
+
+      // Update by ID or where clause
+      if (id) {
+        // Single document update
+        const updateOptions = {
+          id,
+          collection: collectionSlug,
+          data: parsedData,
+          depth,
+          draft,
+          overrideLock,
+          user,
+          ...(filePath && { filePath }),
+          ...(overwriteExistingFiles && { overwriteExistingFiles }),
+        }
+
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Updating single document with ID: ${id}`)
+        }
+        const result = await payload.update({
+          ...updateOptions,
+          data: collections?.[collectionSlug]?.override?.(parsedData, req) || parsedData,
+        } as any)
+
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Successfully updated document with ID: ${id}`)
+        }
+
+        const response = {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Document updated successfully in collection "${collectionSlug}"!
+Updated document:
+\`\`\`json
+${JSON.stringify(result, null, 2)}
+\`\`\``,
+            },
+          ],
+        }
+
+        return (collections?.[collectionSlug]?.overrideResponse?.(response, result, req) ||
+          response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      } else {
+        // Multiple documents update
+        const updateOptions = {
+          collection: collectionSlug,
+          data: parsedData,
+          depth,
+          draft,
+          overrideAccess: true,
+          overrideLock,
+          where: whereClause,
+          ...(filePath && { filePath }),
+          ...(overwriteExistingFiles && { overwriteExistingFiles }),
+        }
+
+        if (verboseLogs) {
+          payload.logger.info(`[payload-mcp] Updating multiple documents with where clause`)
+        }
+        const result = await payload.update({
+          ...updateOptions,
+          data: collections?.[collectionSlug]?.override?.(parsedData, req) || parsedData,
+        } as any)
+
+        const bulkResult = result as { docs?: unknown[]; errors?: unknown[] }
+        const docs = bulkResult.docs || []
+        const errors = bulkResult.errors || []
+
+        if (verboseLogs) {
+          payload.logger.info(
+            `[payload-mcp] Successfully updated ${docs.length} documents, ${errors.length} errors`,
+          )
+        }
+
+        let responseText = `Multiple documents updated in collection "${collectionSlug}"!
+Updated: ${docs.length} documents
+Errors: ${errors.length}
+---`
+
+        if (docs.length > 0) {
+          responseText += `\n\nUpdated documents:
+\`\`\`json
+${JSON.stringify(docs, null, 2)}
+\`\`\``
+        }
+
+        if (errors.length > 0) {
+          responseText += `\n\nErrors:
+\`\`\`json
+${JSON.stringify(errors, null, 2)}
+\`\`\``
+        }
+
+        const response = {
+          content: [
+            {
+              type: 'text' as const,
+              text: responseText,
+            },
+          ],
+        }
+
+        return (collections?.[collectionSlug]?.overrideResponse?.(
+          response,
+          { docs, errors },
+          req,
+        ) || response) as {
+          content: Array<{
+            text: string
+            type: 'text'
+          }>
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      payload.logger.error(
+        `[payload-mcp] Error updating resource in ${collectionSlug}: ${errorMessage}`,
+      )
+
+      const response = {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Error updating resource in collection "${collectionSlug}": ${errorMessage}`,
+          },
+        ],
+      }
+
+      return (collections?.[collectionSlug]?.overrideResponse?.(response, {}, req) || response) as {
+        content: Array<{
+          text: string
+          type: 'text'
+        }>
+      }
+    }
+  }
+
+  if (collections?.[collectionSlug]?.enabled) {
+    const convertedFields = convertCollectionSchemaToZod(schema)
+
+    // Create a new schema that combines the converted fields with update-specific parameters
+    const updateResourceSchema = z.object({
+      ...convertedFields.shape,
+      id: z.string().optional().describe('The ID of the document to update'),
+      depth: z
+        .number()
+        .optional()
+        .default(0)
+        .describe('How many levels deep to populate relationships'),
+      draft: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to update the document as a draft'),
+      filePath: z.string().optional().describe('File path for file uploads'),
+      overrideLock: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('Whether to override document locks'),
+      overwriteExistingFiles: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Whether to overwrite existing files'),
+      where: z
+        .string()
+        .optional()
+        .describe('JSON string for where clause to update multiple documents'),
+    })
+
+    server.tool(
+      `update${collectionSlug.charAt(0).toUpperCase() + toCamelCase(collectionSlug).slice(1)}`,
+      `${toolSchemas.updateResource.description.trim()}\n\n${collections?.[collectionSlug]?.description || ''}`,
+      updateResourceSchema.shape,
+      async (params: Record<string, unknown>) => {
+        const {
+          id,
+          depth,
+          draft,
+          filePath,
+          overrideLock,
+          overwriteExistingFiles,
+          where,
+          ...fieldData
+        } = params
+        // Convert field data back to JSON string format expected by the tool
+        const data = JSON.stringify(fieldData)
+        return await tool(
+          data,
+          id as string | undefined,
+          where as string | undefined,
+          draft as boolean,
+          depth as number,
+          overrideLock as boolean,
+          filePath as string | undefined,
+          overwriteExistingFiles as boolean,
+        )
+      },
+    )
+  }
+}