@payloadcms/plugin-mcp 4.0.0-canary.3 → 4.0.0-internal.17c13d2

package/src/endpoint/access.ts

@@ -1,144 +1,119 @@
-import type { DefaultDocumentIDType, PayloadRequest, TypedUser } from 'payload'
+import type { PayloadRequest, SanitizedPermissions } from 'payload'
 
-import crypto from 'crypto'
-import { UnauthorizedError } from 'payload'
+import { getAccessResults, UnauthorizedError } from 'payload'
 
-import type { AuthorizedMCP, MCPAPIKeysDoc } from '../types.js'
+import type { AuthorizedMCP, MCPItem } from '../types.js'
 
-import { getLogger } from '../utils/getLogger.js'
 import { getPluginConfig } from '../utils/getPluginConfig.js'
 
+export type GetAuthorizedMCPArgs = {
+  overrideAccess: boolean
+  req: PayloadRequest
+}
+
 /**
- * Resolves the API key (or dev-mode session) and returns the items the caller
- * may use. Denied items are dropped from the array.
+ * Resolves the MCP caller and returns the MCP surface authorized for that request.
+ *
+ * Authorization has two layers:
+ * 1. Payload collection/global permissions determine whether built-in operation tools are shown.
+ * 2. MCP `access` callbacks can further hide any configured tool, prompt, or resource.
+ *
+ * Like Payload core operations, `overrideAccess` skips both layers.
  */
-export const getAuthorizedMCP: (args: { req: PayloadRequest }) => Promise<AuthorizedMCP> = async ({
+export const getAuthorizedMCP: (args: GetAuthorizedMCPArgs) => Promise<AuthorizedMCP> = async ({
+  overrideAccess,
   req,
 }) => {
-  const logger = getLogger({ payload: req.payload })
   const pluginConfig = getPluginConfig({ config: req.payload.config })
 
-  const authHeader = req.headers.get('Authorization')
-  const hasBearerToken = authHeader?.startsWith('Bearer ')
-
-  const buildAuthorized = (apiKeyDoc: MCPAPIKeysDoc): AuthorizedMCP => ({
-    items: pluginConfig.items.filter((item) => {
-      switch (item.type) {
-        case 'collectionTool':
-          return apiKeyDoc.access.collections?.[item.collectionSlug]?.[item.configKey] !== false
-        case 'globalTool':
-          return apiKeyDoc.access.globals?.[item.globalSlug]?.[item.configKey] !== false
-        case 'prompt':
-          return apiKeyDoc.access.prompts?.[item.configKey] !== false
-        case 'resource':
-          return apiKeyDoc.access.resources?.[item.configKey] !== false
-        case 'tool':
-          return apiKeyDoc.access.tools?.[item.configKey] !== false
-      }
-    }),
-    overrideAccess:
-      typeof apiKeyDoc.overrideAccess === 'boolean' ? apiKeyDoc.overrideAccess : false,
-    user: apiKeyDoc.user,
-  })
-
-  if (pluginConfig.overrideAuth) {
-    return await pluginConfig.overrideAuth({
-      getAPIKeyDoc: (overrideApiKey) => getAPIKeyDoc({ logger, overrideApiKey, pluginConfig, req }),
-      getAuthorizedMCP: ({ apiKeyDoc }) => buildAuthorized(apiKeyDoc),
+  if (pluginConfig.overrideGetAuthorizedMCP) {
+    return await pluginConfig.overrideGetAuthorizedMCP({
+      overrideAccess,
       pluginConfig,
       req,
     })
   }
 
-  if (process.env.NODE_ENV === 'development' && !hasBearerToken) {
-    logger.info('Dev mode: skipping API key check, using session user')
-    return buildAuthorized({
-      id: -1,
-      access: {},
-      overrideAccess: true,
-      user: req.user ?? null,
-    })
+  if (req.headers) {
+    const headers = new Headers(req.headers)
+    const hasAuthorization = headers.has('Authorization')
+
+    headers.set('DisableAutologin', 'true')
+    req.user = (await req.payload.auth({ headers, req })).user
+
+    if (hasAuthorization && !req.user) {
+      throw new UnauthorizedError(req.t)
+    }
   }
 
-  return buildAuthorized(await getAPIKeyDoc({ logger, pluginConfig, req }))
+  return {
+    items: await filterMCPItems({
+      items: pluginConfig.items,
+      overrideAccess,
+      req,
+    }),
+    overrideAccess,
+    user: req.user,
+  }
 }
 
-const getAPIKeyDoc = async ({
-  logger,
-  overrideApiKey,
-  pluginConfig,
+export const filterMCPItems = async ({
+  items,
+  overrideAccess,
   req,
 }: {
-  logger: ReturnType<typeof getLogger>
-  overrideApiKey?: string
-  pluginConfig: ReturnType<typeof getPluginConfig>
+  items: MCPItem[]
+  overrideAccess: boolean
   req: PayloadRequest
-}): Promise<MCPAPIKeysDoc> => {
-  const authHeader = req.headers.get('Authorization')
-  const hasBearerToken = authHeader?.startsWith('Bearer ')
-
-  const apiKey =
-    overrideApiKey ?? (hasBearerToken ? authHeader?.replace('Bearer ', '').trim() || null : null)
-
-  if (!apiKey) {
-    throw new UnauthorizedError()
+}): Promise<MCPItem[]> => {
+  // Match Payload core: overrideAccess bypasses access evaluation instead of
+  // forcing each access function to return true.
+  if (overrideAccess) {
+    return items
   }
 
-  const sha256APIKeyIndex = crypto
-    .createHmac('sha256', req.payload.secret)
-    .update(apiKey)
-    .digest('hex')
-
-  const doc = await req.payload.db.findOne<MCPAPIKeysDoc>({
-    collection: 'payload-mcp-api-keys',
-    req,
-    where: {
-      apiKeyIndex: { equals: sha256APIKeyIndex },
-    },
-  })
-
-  if (!doc || !doc.user) {
-    throw new UnauthorizedError()
-  }
-
-  logger.info('API Key is valid')
+  const authorizedItems: MCPItem[] = []
 
-  const userRef = doc.user
-  const userID =
-    typeof userRef === 'object' && userRef !== null && 'id' in userRef
-      ? userRef.id
-      : (userRef as unknown as DefaultDocumentIDType)
+  const permissions = await getAccessResults({ req })
 
-  const user = (await req.payload.findByID({
-    id: userID,
-    collection: pluginConfig.userCollection,
-    depth: 0,
-    disableErrors: true,
-    req,
-  })) as null | TypedUser
-
-  if (!user) {
-    throw new UnauthorizedError()
+  for (const item of items) {
+    if (!(await checkItemAccess({ item, permissions, req }))) {
+      continue
+    }
+    authorizedItems.push(item)
   }
 
-  try {
-    await req.payload.db.updateOne({
-      id: doc.id,
-      collection: 'payload-mcp-api-keys',
-      data: { lastUsed: new Date().toISOString() },
-      req,
-      returning: false,
-    })
-  } catch (err) {
-    logger.warn({ err, msg: 'Failed to update MCP API key last-used timestamp' })
-  }
+  return authorizedItems
+}
 
-  return {
-    ...doc,
-    user: {
-      ...user,
-      _strategy: 'mcp-api-key' as const,
-      collection: pluginConfig.userCollection,
-    },
+/**
+ * Runs MCP item access callbacks
+ */
+const checkItemAccess = async ({
+  item,
+  permissions,
+  req,
+}: {
+  item: MCPItem
+  permissions?: SanitizedPermissions
+  req: PayloadRequest
+}): Promise<boolean> => {
+  switch (item.type) {
+    case 'collectionTool':
+      return (
+        !item.tool.access ||
+        (await item.tool.access({ collectionSlug: item.collectionSlug, permissions, req }))
+      )
+    case 'globalTool':
+      return (
+        !item.tool.access ||
+        (await item.tool.access({ globalSlug: item.globalSlug, permissions, req }))
+      )
+    case 'prompt':
+      return !item.prompt.access || (await item.prompt.access({ permissions, req }))
+    case 'resource':
+      return !item.resource.access || (await item.resource.access({ permissions, req }))
+    case 'tool':
+      return !item.tool.access || (await item.tool.access({ permissions, req }))
   }
 }

package/src/endpoint/index.ts

@@ -13,7 +13,20 @@ export const mcpEndpoint: PayloadHandler = async (req) => {
   req.payloadAPI = 'MCP' as const
 
   const pluginConfig = getPluginConfig({ config: req.payload.config })
-  const authorizedMCP = await getAuthorizedMCP({ req })
+  const overrideAccessParam = new URL(req.url).searchParams.get('overrideAccess')
+
+  if (overrideAccessParam !== null && process.env.NODE_ENV !== 'development') {
+    throw new APIError('MCP overrideAccess is only available in development.', 400)
+  }
+
+  let overrideAccess = false
+  if (overrideAccessParam === 'true') {
+    overrideAccess = true
+  } else if (overrideAccessParam !== null && overrideAccessParam !== 'false') {
+    throw new APIError('MCP overrideAccess must be "true" or "false".', 400)
+  }
+
+  const authorizedMCP = await getAuthorizedMCP({ overrideAccess, req })
 
   const server = buildMcpServer({ authorizedMCP, pluginConfig, req })
 

package/src/exports/client.ts

@@ -1,5 +1,3 @@
 'use client'
-export { AccessField } from '../components/AccessField/index.client.js'
-export { APIKeyField } from '../components/APIKeyField/index.client.js'
-export { APIKeysEmptyState } from '../components/APIKeysEmptyState/index.client.js'
-export { MCPSettingsMenu } from '../components/SettingsMenu/index.client.js'
+
+export {}

package/src/exports/internal.ts

@@ -0,0 +1 @@
+export { filterMCPItems, getAuthorizedMCP } from '../endpoint/access.js'

package/src/index.ts

@@ -1,14 +1,9 @@
-import type { AcceptedLanguages } from '@payloadcms/translations'
+import { definePlugin } from 'payload'
 
-import { defaultUserCollection, definePlugin } from 'payload'
-
-import type { PluginDefaultTranslationsObject } from './translations/types.js'
 import type { AuthorizedMCP, MCPPluginConfig, SanitizedMCPPluginConfig } from './types.js'
 
-import { getAPIKeysCollection } from './collection/index.js'
 import { mcpEndpoint } from './endpoint/index.js'
 import { sanitizeMCPConfig } from './mcp/sanitizeMCPConfig.js'
-import { translations } from './translations/index.js'
 
 declare module 'payload' {
   export interface PayloadRequest {
@@ -28,15 +23,6 @@ export const mcpPlugin = definePlugin<MCPPluginConfig>({
   slug: '@payloadcms/plugin-mcp',
   order: 10,
   plugin: ({ config, plugins, ...rawConfig }) => {
-    // If a project has no auth collection yet, add the default users collection
-    // so the relationship target and default `userCollection` exist.
-    if (!config.admin?.user) {
-      const firstCollectionWithAuth = (config.collections ?? []).find(({ auth }) => Boolean(auth))
-      if (!firstCollectionWithAuth) {
-        ;(config.collections ??= []).push(defaultUserCollection)
-      }
-    }
-
     const pluginConfig = sanitizeMCPConfig({ config, pluginConfig: rawConfig })
 
     // Stash the sanitized config on plugin options so `getPluginConfig()` reads it.
@@ -46,55 +32,12 @@ export const mcpPlugin = definePlugin<MCPPluginConfig>({
       registered.sanitizedOptions = pluginConfig as unknown as typeof registered.options
     }
 
-    ;(config.collections ??= []).push(getAPIKeysCollection({ pluginConfig }))
-
-    if (!config.i18n) {
-      config.i18n = {}
-    }
-
-    if (!config.i18n.translations) {
-      config.i18n.translations = {}
-    }
-
-    const supportedLanguageKeys = config.i18n.supportedLanguages
-      ? Object.keys(config.i18n.supportedLanguages)
-      : ['en']
-
-    for (const lang of supportedLanguageKeys) {
-      const pluginEntry = translations[lang as keyof typeof translations]
-      if (!pluginEntry) {
-        continue
-      }
-
-      const typedLocale = lang as AcceptedLanguages
-      const existing = (config.i18n.translations[typedLocale] ?? {}) as Record<string, unknown>
-      config.i18n.translations[typedLocale] = {
-        ...existing,
-        'plugin-mcp': pluginEntry.translations['plugin-mcp'],
-      } as PluginDefaultTranslationsObject
-    }
-
-    // Keep the API-keys collection registered even when disabled, so DB schema
-    // and generated types don't drift between enabled/disabled environments.
     if (pluginConfig.disabled) {
       return config
     }
 
     return {
       ...config,
-      admin: {
-        ...config.admin,
-        components: {
-          ...config.admin?.components,
-          userMenuSettingsItems: [
-            ...(config.admin?.components?.userMenuSettingsItems ?? []),
-            {
-              group: 'MCP',
-              items: ['@payloadcms/plugin-mcp/client#MCPSettingsMenu'],
-            },
-          ],
-        },
-      },
       endpoints: [
         ...(config.endpoints ?? []),
         // Payload prefixes /api, so the full path is /api/mcp.

package/src/mcp/buildMcpServer.ts

@@ -109,7 +109,12 @@ export const buildMcpServer = ({
       }
     }
 
-    const handlerArgs = { authorizedMCP, input: toolInput, req, serverContext }
+    const handlerArgs = {
+      authorizedMCP,
+      input: toolInput,
+      req,
+      serverContext,
+    }
     const response = await (match.type === 'collectionTool'
       ? match.tool.handler({ ...handlerArgs, collectionSlug: slug })
       : match.tool.handler({ ...handlerArgs, globalSlug: slug }))

package/src/mcp/builtin/collections/countTool.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+import { whereSchema } from '../../../utils/whereSchema.js'
+
+const DEFAULT_DESCRIPTION =
+  'Count documents in any collection by passing the collection slug and optional where clause.'
+
+export const countDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.read),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Documents',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    locale: z.string().describe('Optional: locale code to count documents in').optional(),
+    trash: z
+      .boolean()
+      .describe('Optional: include soft-deleted documents when trash is enabled on the collection')
+      .optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering. Use field names with Payload operators, and/or arrays for grouping. Example: {"title":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, trash, where } = input
+
+  logger.info(`Counting documents in collection: ${collectionSlug}`)
+
+  try {
+    const result = await payload.count({
+      collection: collectionSlug,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(locale ? { locale } : {}),
+      ...(trash !== undefined ? { trash } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${collectionSlug}" contains ${result.totalDocs} matching documents.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting documents in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting documents in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/collections/countVersionsTool.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+import { whereSchema } from '../../../utils/whereSchema.js'
+
+const DEFAULT_DESCRIPTION =
+  'Count document versions in any version-enabled collection by passing the collection slug and optional where clause.'
+
+export const countVersionsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) &&
+    Boolean(args.permissions?.collections?.[args.collectionSlug]?.readVersions),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+    title: 'Count Versions',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    locale: z.string().describe('Optional: locale code to count versions in').optional(),
+    where: whereSchema
+      .describe(
+        'Optional: where clause for filtering versions. Version document fields are usually under "version". Example: {"version.title":{"contains":"test"}}',
+      )
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const { locale, where } = input
+
+  logger.info(`Counting versions in collection: ${collectionSlug}`)
+
+  try {
+    const result = await payload.countVersions({
+      collection: collectionSlug,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(locale ? { locale } : {}),
+      ...(where ? { where } : {}),
+    })
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Collection "${collectionSlug}" contains ${result.totalDocs} matching versions.\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error counting versions in ${collectionSlug}: ${errorMessage}`)
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ **Error counting versions in collection "${collectionSlug}":** ${errorMessage}`,
+        },
+      ],
+      isError: true,
+    }
+  }
+})

package/src/mcp/builtin/collections/createTool.ts

@@ -2,6 +2,7 @@ import type { SelectType } from 'payload'
 
 import { z } from 'zod'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 import {
@@ -17,6 +18,8 @@ const DEFAULT_DESCRIPTION =
   'Create a document in any collection by passing the collection slug and data.'
 
 export const createDocumentTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
   annotations: {
     destructiveHint: false,
     idempotentHint: false,

package/src/mcp/builtin/collections/deleteTool.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
 
+import { defaultAccess } from '../../../defaultAccess.js'
 import { defineCollectionTool } from '../../../defineTool.js'
 import { getLogger } from '../../../utils/getLogger.js'
 import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
@@ -9,6 +10,8 @@ const DEFAULT_DESCRIPTION =
   'Delete documents in any collection by passing the collection slug and ID or where clause.'
 
 export const deleteDocumentsTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.delete),
   annotations: {
     destructiveHint: true,
     idempotentHint: false,

package/src/mcp/builtin/collections/duplicateTool.ts

@@ -0,0 +1,135 @@
+import type { PopulateType, SelectType } from 'payload'
+
+import { z } from 'zod'
+
+import { defaultAccess } from '../../../defaultAccess.js'
+import { defineCollectionTool } from '../../../defineTool.js'
+import { getLogger } from '../../../utils/getLogger.js'
+import {
+  getCollectionVirtualFieldNames,
+  stripVirtualFields,
+} from '../../../utils/getVirtualFieldNames.js'
+import { localAPIDefaults } from '../../../utils/localAPIDefaults.js'
+import { transformPointDataToPayload } from '../../../utils/transformPointDataToPayload.js'
+import { formatCollectionError } from './formatCollectionError.js'
+
+const DEFAULT_DESCRIPTION =
+  'Duplicate a document in any collection by passing the collection slug and source document ID.'
+
+export const duplicateDocumentTool = defineCollectionTool({
+  access: (args) =>
+    defaultAccess(args) && Boolean(args.permissions?.collections?.[args.collectionSlug]?.create),
+  annotations: {
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+    readOnlyHint: false,
+    title: 'Duplicate Document',
+  },
+  description: DEFAULT_DESCRIPTION,
+  input: z.object({
+    id: z.union([z.string(), z.number()]).describe('The ID of the document to duplicate'),
+    data: z
+      .record(z.string(), z.unknown())
+      .describe('Optional: fields to override on the duplicated document')
+      .optional(),
+    depth: z
+      .number()
+      .int()
+      .min(0)
+      .max(10)
+      .describe('How many levels deep to populate relationships in response')
+      .optional()
+      .default(0),
+    draft: z
+      .boolean()
+      .describe('Whether to create the duplicate as a draft')
+      .optional()
+      .default(false),
+    fallbackLocale: z
+      .string()
+      .describe('Optional: fallback locale code to use when requested locale is not available')
+      .optional(),
+    locale: z
+      .string()
+      .describe(
+        'Optional: locale code to duplicate in (e.g., "en", "es"). Defaults to the default locale',
+      )
+      .optional(),
+    populate: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: control which fields to include from populated relationship or upload documents.',
+      )
+      .optional(),
+    select: z
+      .record(z.string(), z.unknown())
+      .describe(
+        'Optional: define exactly which fields you\'d like to return in the response, e.g., {"title": true}',
+      )
+      .optional(),
+    selectedLocales: z
+      .array(z.string())
+      .describe('Optional: localized field locales to include in the duplicated document')
+      .optional(),
+    showHiddenFields: z
+      .boolean()
+      .describe('Optional: include hidden fields in the duplicated document response')
+      .optional(),
+  }),
+}).handler(async ({ authorizedMCP, collectionSlug, input, req }) => {
+  const payload = req.payload
+  const logger = getLogger({ payload })
+  const {
+    id,
+    data,
+    depth,
+    draft,
+    fallbackLocale,
+    locale,
+    populate,
+    select,
+    selectedLocales,
+    showHiddenFields,
+  } = input
+
+  logger.info(`Duplicating document in collection: ${collectionSlug} with ID: ${id}`)
+
+  try {
+    const virtualFieldNames = getCollectionVirtualFieldNames(payload.config, collectionSlug)
+    const inputData = data ? stripVirtualFields(data, virtualFieldNames) : undefined
+    const parsedData = inputData ? transformPointDataToPayload(inputData) : undefined
+
+    const result = await payload.duplicate({
+      id,
+      collection: collectionSlug,
+      depth,
+      draft,
+      req,
+      ...localAPIDefaults(authorizedMCP),
+      ...(parsedData ? { data: parsedData } : {}),
+      ...(locale ? { locale } : {}),
+      ...(fallbackLocale ? { fallbackLocale } : {}),
+      ...(populate ? { populate: populate as PopulateType } : {}),
+      ...(select ? { select: select as SelectType } : {}),
+      ...(selectedLocales ? { selectedLocales } : {}),
+      ...(showHiddenFields !== undefined ? { showHiddenFields } : {}),
+    })
+
+    logger.info(`Successfully duplicated document in ${collectionSlug} from ID: ${id}`)
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Document duplicated successfully in collection "${collectionSlug}"!\nDuplicated document:\n\`\`\`json\n${JSON.stringify(result)}\n\`\`\``,
+        },
+      ],
+      doc: result as Record<string, unknown>,
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    logger.error(`Error duplicating document in ${collectionSlug}: ${errorMessage}`)
+    return formatCollectionError({ action: 'duplicating', collectionSlug, error, req })
+  }
+})