@payloadcms/plugin-mcp 4.0.0-internal.ccea85d → 4.0.0-internal.cd47d20

package/dist/utils/whereSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"whereSchema.d.ts","sourceRoot":"","sources":["../../src/utils/whereSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CASqD,CAAA"}

package/dist/utils/whereSchema.js

@@ -1,13 +0,0 @@
-import { validOperators } from 'payload/shared';
-import { z } from 'zod';
-const whereFieldSchema = z.partialRecord(z.enum(validOperators), z.unknown()).describe('Field query operators');
-/**
- * - Validates the `where` input of collection tools against Payload's `Where` shape
- * - Field keys map to operator objects restricted to `validOperators`
- * - `and` / `or` nest recursively
- */ export const whereSchema = z.lazy(()=>z.object({
-        and: z.array(whereSchema).optional(),
-        or: z.array(whereSchema).optional()
-    }).catchall(whereFieldSchema)).describe('Where clause using field names with Payload query operators, plus and/or groups');
-
-//# sourceMappingURL=whereSchema.js.map

package/dist/utils/whereSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/whereSchema.ts"],"sourcesContent":["import type { Where } from 'payload'\n\nimport { validOperators } from 'payload/shared'\nimport { z } from 'zod'\n\nconst whereFieldSchema = z\n  .partialRecord(z.enum(validOperators), z.unknown())\n  .describe('Field query operators')\n\n/**\n * - Validates the `where` input of collection tools against Payload's `Where` shape\n * - Field keys map to operator objects restricted to `validOperators`\n * - `and` / `or` nest recursively\n */\nexport const whereSchema: z.ZodType<Where> = z\n  .lazy(() =>\n    z\n      .object({\n        and: z.array(whereSchema).optional(),\n        or: z.array(whereSchema).optional(),\n      })\n      .catchall(whereFieldSchema),\n  )\n  .describe('Where clause using field names with Payload query operators, plus and/or groups')\n"],"names":["validOperators","z","whereFieldSchema","partialRecord","enum","unknown","describe","whereSchema","lazy","object","and","array","optional","or","catchall"],"mappings":"AAEA,SAASA,cAAc,QAAQ,iBAAgB;AAC/C,SAASC,CAAC,QAAQ,MAAK;AAEvB,MAAMC,mBAAmBD,EACtBE,aAAa,CAACF,EAAEG,IAAI,CAACJ,iBAAiBC,EAAEI,OAAO,IAC/CC,QAAQ,CAAC;AAEZ;;;;CAIC,GACD,OAAO,MAAMC,cAAgCN,EAC1CO,IAAI,CAAC,IACJP,EACGQ,MAAM,CAAC;QACNC,KAAKT,EAAEU,KAAK,CAACJ,aAAaK,QAAQ;QAClCC,IAAIZ,EAAEU,KAAK,CAACJ,aAAaK,QAAQ;IACnC,GACCE,QAAQ,CAACZ,mBAEbI,QAAQ,CAAC,mFAAkF"}

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

@@ -1,84 +0,0 @@
-import type { CollectionSlug, PayloadRequest } from 'payload'
-
-import type { MCPToolResponse } from '../../../types.js'
-
-import { getCollectionInputSchema } from '../../../utils/schemaConversion/getEntityInputSchema.js'
-
-const getValidationErrors = (error: unknown): undefined | unknown[] => {
-  if (!error || typeof error !== 'object') {
-    return undefined
-  }
-
-  const data = 'data' in error ? error.data : undefined
-  if (!data || typeof data !== 'object' || !('errors' in data) || !Array.isArray(data.errors)) {
-    return undefined
-  }
-
-  return data.errors
-}
-
-const isSchemaError = (error: unknown, message: string): boolean => {
-  if (getValidationErrors(error)) {
-    return true
-  }
-
-  const name = error && typeof error === 'object' && 'name' in error ? error.name : undefined
-
-  return (
-    name === 'CastError' ||
-    name === 'ValidationError' ||
-    message.includes('Cast to ') ||
-    message.includes('validation failed')
-  )
-}
-
-export const formatCollectionError = ({
-  action,
-  collectionSlug,
-  error,
-  req,
-}: {
-  action: 'creating' | 'duplicating' | 'updating'
-  collectionSlug: CollectionSlug
-  error: unknown
-  req: PayloadRequest
-}): MCPToolResponse => {
-  const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-  const errors = getValidationErrors(error) ?? [{ message: errorMessage }]
-
-  if (!isSchemaError(error, errorMessage)) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}`,
-        },
-      ],
-      isError: true,
-    }
-  }
-
-  const schema = getCollectionInputSchema({ collectionSlug, req })
-  const schemaText = schema
-    ? `\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``
-    : ''
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: `Error ${action} document in collection "${collectionSlug}": ${errorMessage}${schemaText}`,
-      },
-    ],
-    isError: true,
-    ...(schema
-      ? {
-          structuredContent: {
-            collectionSlug,
-            errors,
-            schema,
-          },
-        }
-      : {}),
-  }
-}

package/src/mcp/builtin/validateEntityData.ts

@@ -1,132 +0,0 @@
-import type { CollectionSlug, GlobalSlug, PayloadRequest, SanitizedConfig } from 'payload'
-
-import { CfWorkerJsonSchemaValidator } from '@modelcontextprotocol/server/validators/cf-worker'
-
-import type { JsonSchemaType, MCPToolResponse } from '../../types.js'
-
-import {
-  getCollectionInputSchema,
-  getGlobalInputSchema,
-} from '../../utils/schemaConversion/getEntityInputSchema.js'
-
-/**
- * Keep the default `shortcircuit: true` - `false` makes validating nested rich text exponentially slow.
- */
-const validator = new CfWorkerJsonSchemaValidator({ shortcircuit: true })
-
-type EntityValidator = {
-  schema: JsonSchemaType
-  validate: ReturnType<(typeof validator)['getValidator']>
-}
-
-/**
- * - Caches each entity's schema and validator, so both are only built on the first request.
- * - Keyed by payload config, then by entity type, slug, partial and language.
- */
-const validatorCache = new WeakMap<SanitizedConfig, Map<string, EntityValidator>>()
-
-export const validateCollectionData = ({
-  collectionSlug,
-  data,
-  partial,
-  req,
-}: {
-  collectionSlug: CollectionSlug
-  data: Record<string, unknown>
-  partial?: boolean
-  req: PayloadRequest
-}): MCPToolResponse | null =>
-  validateData({
-    slug: collectionSlug,
-    buildSchema: () => getCollectionInputSchema({ collectionSlug, req }),
-    data,
-    entity: 'collection',
-    partial,
-    req,
-  })
-
-export const validateGlobalData = ({
-  data,
-  globalSlug,
-  req,
-}: {
-  data: Record<string, unknown>
-  globalSlug: GlobalSlug
-  req: PayloadRequest
-}): MCPToolResponse | null =>
-  validateData({
-    slug: globalSlug,
-    buildSchema: () => getGlobalInputSchema({ globalSlug, req }),
-    data,
-    entity: 'global',
-    partial: true,
-    req,
-  })
-
-const validateData = ({
-  slug,
-  buildSchema,
-  data,
-  entity,
-  partial,
-  req,
-}: {
-  buildSchema: () => JsonSchemaType | null
-  data: Record<string, unknown>
-  entity: 'collection' | 'global'
-  partial?: boolean
-  req: PayloadRequest
-  slug: string
-}): MCPToolResponse | null => {
-  let cache = validatorCache.get(req.payload.config)
-  if (!cache) {
-    cache = new Map()
-    validatorCache.set(req.payload.config, cache)
-  }
-
-  const cacheKey = `${entity}:${slug}:${partial ? 'partial' : 'full'}:${req.i18n.language}`
-  let entityValidator = cache.get(cacheKey)
-
-  if (!entityValidator) {
-    const schema = buildSchema()
-
-    if (!schema) {
-      return null
-    }
-
-    entityValidator = {
-      schema,
-      validate: validator.getValidator(partial ? withoutRequired(schema) : schema),
-    }
-    cache.set(cacheKey, entityValidator)
-  }
-
-  const result = entityValidator.validate(data)
-
-  if (result.valid) {
-    return null
-  }
-
-  const { schema } = entityValidator
-
-  return {
-    content: [
-      {
-        type: 'text',
-        text: `Invalid data for ${entity} "${slug}": ${result.errorMessage}\n\nUse this schema for data:\n\`\`\`json\n${JSON.stringify(schema)}\n\`\`\``,
-      },
-    ],
-    isError: true,
-    structuredContent: {
-      [`${entity}Slug`]: slug,
-      errors: [{ message: result.errorMessage }],
-      schema,
-    },
-  }
-}
-
-/** Updates are partial — drop the schema's top-level `required` before validating. */
-const withoutRequired = (schema: JsonSchemaType): JsonSchemaType => {
-  const { required: _required, ...rest } = schema
-  return rest
-}

package/src/utils/getVirtualFieldNames.ts

@@ -1,53 +0,0 @@
-import type { SanitizedConfig } from 'payload'
-
-import { fieldIsVirtual } from 'payload/shared'
-
-/**
- * Returns the names of all top-level virtual fields for a given collection slug.
- */
-export function getCollectionVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  const collection = config.collections.find((c) => c.slug === slug)
-
-  if (!collection) {
-    return []
-  }
-
-  return collection.flattenedFields
-    .filter((field) => 'name' in field && fieldIsVirtual(field))
-    .map((field) => (field as { name: string }).name)
-}
-
-/**
- * Returns the names of all top-level virtual fields for a given global slug.
- */
-export function getGlobalVirtualFieldNames(config: SanitizedConfig, slug: string): string[] {
-  const global = config.globals.find((g) => g.slug === slug)
-
-  if (!global) {
-    return []
-  }
-
-  return global.flattenedFields
-    .filter((field) => 'name' in field && fieldIsVirtual(field))
-    .map((field) => (field as { name: string }).name)
-}
-
-/**
- * Strips virtual field values from a data object given a list of virtual field names.
- */
-export function stripVirtualFields(
-  data: Record<string, unknown>,
-  virtualFieldNames: string[],
-): Record<string, unknown> {
-  if (virtualFieldNames.length === 0) {
-    return data
-  }
-
-  const stripped = { ...data }
-
-  for (const name of virtualFieldNames) {
-    delete stripped[name]
-  }
-
-  return stripped
-}

package/src/utils/schemaConversion/filterFieldsByAccess.ts

@@ -1,123 +0,0 @@
-import type {
-  FlattenedBlock,
-  FlattenedField,
-  Operation,
-  SanitizedDocumentPermissions,
-  SanitizedFieldsPermissions,
-} from 'payload'
-
-type FieldOperation = Exclude<Operation, 'delete'>
-type AllowedFieldOperations = Record<FieldOperation, boolean>
-
-/**
- * Filters fields using the access results in `permissions`. `shouldExcludeField` receives the
- * operations allowed by the entity, field, and its parents and decides whether to remove the
- * field.
- *
- * Arrays, groups, named tabs, and blocks are filtered recursively. Rows and unnamed tabs are
- * flattened by Payload, so their children are filtered at the containing level.
- *
- * @example Include fields writable through any collection operation the user can perform.
- * ```ts
- * filterFieldsByAccess({
- *   fields,
- *   permissions: collectionPermissions,
- *   shouldExcludeField: ({ create, update }) => !create && !update,
- * })
- * ```
- */
-export const filterFieldsByAccess = ({
-  blocks,
-  fields,
-  permissions,
-  shouldExcludeField,
-}: {
-  blocks?: FlattenedBlock[]
-  fields: FlattenedField[]
-  permissions: SanitizedDocumentPermissions
-  shouldExcludeField: (allowedOperations: AllowedFieldOperations) => boolean
-}): FlattenedField[] => {
-  const filterFields = (
-    nestedFields: FlattenedField[],
-    nestedPermissions: SanitizedFieldsPermissions | undefined,
-    parentAllowedOperations: AllowedFieldOperations,
-  ): FlattenedField[] => {
-    const accessibleFields: FlattenedField[] = []
-
-    for (const field of nestedFields) {
-      const fieldPermissions = nestedPermissions === true ? true : nestedPermissions?.[field.name]
-      const isOperationAllowed = (operation: FieldOperation): boolean =>
-        parentAllowedOperations[operation] &&
-        (fieldPermissions === true || fieldPermissions?.[operation] === true)
-      const allowedOperations: AllowedFieldOperations = {
-        create: isOperationAllowed('create'),
-        read: isOperationAllowed('read'),
-        update: isOperationAllowed('update'),
-      }
-
-      if (shouldExcludeField(allowedOperations)) {
-        continue
-      }
-
-      if (field.type === 'blocks') {
-        const accessibleBlocks: (FlattenedBlock | string)[] = []
-
-        for (const blockOrReference of field.blocks) {
-          const block =
-            typeof blockOrReference === 'string'
-              ? blocks?.find(({ slug }) => slug === blockOrReference)
-              : blockOrReference
-
-          if (!block) {
-            continue
-          }
-
-          const blockPermissions =
-            fieldPermissions === true
-              ? true
-              : fieldPermissions?.blocks === true
-                ? true
-                : fieldPermissions?.blocks?.[block.slug]
-
-          accessibleBlocks.push({
-            ...block,
-            flattenedFields: filterFields(
-              block.flattenedFields,
-              blockPermissions === true ? true : blockPermissions?.fields,
-              allowedOperations,
-            ),
-          })
-        }
-
-        if (accessibleBlocks.length === 0) {
-          continue
-        }
-
-        accessibleFields.push({ ...field, blocks: accessibleBlocks })
-        continue
-      }
-
-      if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
-        accessibleFields.push({
-          ...field,
-          flattenedFields: filterFields(
-            field.flattenedFields,
-            fieldPermissions === true ? true : fieldPermissions?.fields,
-            allowedOperations,
-          ),
-        })
-        continue
-      }
-
-      accessibleFields.push(field)
-    }
-
-    return accessibleFields
-  }
-
-  return filterFields(fields, permissions.fields, {
-    create: 'create' in permissions && permissions.create === true,
-    read: permissions.read === true,
-    update: permissions.update === true,
-  })
-}

package/src/utils/schemaConversion/getEntityInputSchema.ts

@@ -1,96 +0,0 @@
-import {
-  type CollectionSlug,
-  entityToStandaloneJSONSchema,
-  type FlattenedField,
-  type GlobalSlug,
-  type PayloadRequest,
-  type SanitizedCollectionConfig,
-  type SanitizedCollectionPermission,
-  type SanitizedGlobalConfig,
-  type SanitizedGlobalPermission,
-} from 'payload'
-
-import type { JsonSchemaType } from '../../types.js'
-
-import { filterFieldsByAccess } from './filterFieldsByAccess.js'
-import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
-
-export const getCollectionInputSchema = ({
-  collectionSlug,
-  permissions,
-  req,
-}: {
-  collectionSlug: CollectionSlug
-  permissions?: SanitizedCollectionPermission
-  req: PayloadRequest
-}): JsonSchemaType | null => {
-  const collection = req.payload.collections[collectionSlug]?.config
-
-  if (!collection) {
-    return null
-  }
-
-  if (!permissions) {
-    return buildEntityInputSchema({ entity: collection, req })
-  }
-
-  const fieldsAllowedByAccess = filterFieldsByAccess({
-    blocks: req.payload.config.blocks,
-    fields: collection.flattenedFields,
-    permissions,
-    shouldExcludeField: ({ create, update }) => !create && !update,
-  })
-
-  return buildEntityInputSchema({ entity: collection, fields: fieldsAllowedByAccess, req })
-}
-
-export const getGlobalInputSchema = ({
-  globalSlug,
-  permissions,
-  req,
-}: {
-  globalSlug: GlobalSlug
-  permissions?: SanitizedGlobalPermission
-  req: PayloadRequest
-}): JsonSchemaType | null => {
-  const global = req.payload.config.globals.find((globalConfig) => globalConfig.slug === globalSlug)
-
-  if (!global) {
-    return null
-  }
-
-  if (!permissions) {
-    return buildEntityInputSchema({ entity: global, req })
-  }
-
-  const fieldsAllowedByAccess = filterFieldsByAccess({
-    blocks: req.payload.config.blocks,
-    fields: global.flattenedFields,
-    permissions,
-    shouldExcludeField: ({ create, update }) => !create && !update,
-  })
-
-  return buildEntityInputSchema({ entity: global, fields: fieldsAllowedByAccess, req })
-}
-
-const buildEntityInputSchema = ({
-  entity,
-  fields = entity.flattenedFields,
-  req,
-}: {
-  entity: SanitizedCollectionConfig | SanitizedGlobalConfig
-  fields?: FlattenedField[]
-  req: PayloadRequest
-}): JsonSchemaType => {
-  // The core schema generator reads flattenedFields from the entity and has no fields argument.
-  const entityForSchema = { ...entity, flattenedFields: fields }
-  const schema = entityToStandaloneJSONSchema({
-    config: req.payload.config,
-    defaultIDType: req.payload.db.defaultIDType,
-    entity: entityForSchema,
-    i18n: req.i18n,
-    variant: 'input',
-  }) as unknown as JsonSchemaType
-
-  return sanitizeEntitySchema(schema)
-}

package/src/utils/schemaConversion/sanitizeEntitySchema.spec.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { JsonSchemaType } from '../../types.js'
-
-import { sanitizeEntitySchema } from './sanitizeEntitySchema.js'
-
-describe('sanitizeEntitySchema', () => {
-  it('renames the Lexical node-union definition to a short name and keeps it a strict oneOf', () => {
-    // Shaped like the schema the MCP server prepares for a collection with a Lexical richText field
-    // (Payload's `input` variant): a `$defs` node union (a `oneOf` of node shapes). The input variant
-    // already types the relationship node's `value` as a bare ID - there is no populated-doc `$ref` to
-    // reduce here (the variant did that upstream), so sanitize leaves the value untouched.
-    const standalone: JsonSchemaType = {
-      type: 'object',
-      $defs: {
-        LexicalNodes_ABCDEF12: {
-          oneOf: [
-            {
-              type: 'object',
-              additionalProperties: false,
-              properties: { type: { const: 'paragraph' } },
-              required: ['type'],
-            },
-            {
-              type: 'object',
-              additionalProperties: false,
-              properties: {
-                type: { const: 'relationship' },
-                value: { type: 'string', description: 'The related document ID.' },
-              },
-              required: ['type'],
-            },
-          ],
-        },
-      },
-      properties: {
-        id: { type: 'string' },
-        content: {
-          type: 'object',
-          properties: {
-            root: {
-              type: 'object',
-              properties: {
-                children: { type: 'array', items: { $ref: '#/$defs/LexicalNodes_ABCDEF12' } },
-              },
-            },
-          },
-        },
-      },
-    }
-
-    expect(sanitizeEntitySchema(standalone)).toStrictEqual({
-      type: 'object',
-      $defs: {
-        // The node union is renamed to a short, readable `node`, and stays a strict discriminated
-        // `oneOf` - not loosened to `anyOf`.
-        node: {
-          oneOf: [
-            {
-              type: 'object',
-              additionalProperties: false,
-              properties: { type: { const: 'paragraph' } },
-              required: ['type'],
-            },
-            {
-              type: 'object',
-              additionalProperties: false,
-              properties: {
-                type: { const: 'relationship' },
-                // The value is already ID-only from the input variant - left as-is.
-                value: { type: 'string', description: 'The related document ID.' },
-              },
-              required: ['type'],
-            },
-          ],
-        },
-      },
-      properties: {
-        // Managed timestamps are excluded upstream by the `input` variant. `id` stays because it's
-        // a valid optional input (a client may supply a custom ID).
-        id: { type: 'string' },
-        content: {
-          type: 'object',
-          properties: {
-            root: {
-              type: 'object',
-              properties: {
-                children: { type: 'array', items: { $ref: '#/$defs/node' } },
-              },
-            },
-          },
-        },
-      },
-    })
-  })
-})