@payloadcms/plugin-mcp 4.0.0-internal.5b1e7cd → 4.0.0-internal.a0ef1b8

package/src/utils/schemaConversion/convertCollectionSchemaToZod.ts

@@ -1,52 +0,0 @@
-import type { JSONSchema4 } from 'json-schema'
-
-import { jsonSchemaToZod } from 'json-schema-to-zod'
-import * as ts from 'typescript'
-import { z } from 'zod'
-
-import { sanitizeJsonSchema } from './sanitizeJsonSchema.js'
-import { simplifyRelationshipFields } from './simplifyRelationshipFields.js'
-import { transformPointFieldsForMCP } from './transformPointFields.js'
-
-export const convertCollectionSchemaToZod = (schema: JSONSchema4) => {
-  try {
-    // Clone to avoid mutating the original schema (used elsewhere for tool listing)
-    const schemaClone = JSON.parse(JSON.stringify(schema)) as JSONSchema4
-
-    const sanitized = sanitizeJsonSchema(schemaClone)
-    const pointTransformed = transformPointFieldsForMCP(sanitized)
-    const zodSchemaAsString = jsonSchemaToZod(simplifyRelationshipFields(pointTransformed))
-
-    // Transpile TypeScript to JavaScript
-    const transpileResult = ts.transpileModule(zodSchemaAsString, {
-      compilerOptions: {
-        module: ts.ModuleKind.CommonJS,
-        removeComments: true,
-        strict: false,
-        target: ts.ScriptTarget.ES2018,
-      },
-    })
-
-    /**
-     * This Function evaluation is safe because:
-     * 1. The input schema comes from Payload's collection configuration, which is controlled by the application developer
-     * 2. The jsonSchemaToZod library converts JSON Schema to Zod schema definitions, producing only type validation code
-     * 3. The transpiled output contains only Zod schema definitions (z.string(), z.number(), etc.) - no executable logic
-     * 4. The resulting Zod schema is used only for parameter validation in MCP tools, not for data processing
-     * 5. No user input or external data is involved in the schema generation process
-     */
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    return new Function('z', `return ${transpileResult.outputText}`)(z)
-  } catch (error) {
-    // If schema conversion fails (e.g., due to Zod v4 toJSONSchema null-check bug
-    // with record schemas that have undefined valueType, or bundler transforms
-    // stripping Zod internals), return a permissive schema so tools/list doesn't
-    // crash entirely. The tool will still be listed but without strict validation.
-    // See: https://github.com/colinhacks/zod/issues/5821
-    console.warn(
-      `[plugin-mcp] Schema conversion failed, using permissive fallback:`,
-      error instanceof Error ? error.message : error,
-    )
-    return z.record(z.any())
-  }
-}

package/src/utils/schemaConversion/sanitizeJsonSchema.ts

@@ -1,62 +0,0 @@
-import type { JSONSchema4 } from 'json-schema'
-
-/**
- * Removes internal Payload properties (id, createdAt, updatedAt) from a
- * JSON Schema so they don't appear in the generated Zod validation schema.
- * Also strips `id` from the `required` array when present.
- *
- * Additionally normalizes nullable type arrays (e.g. `['array', 'null']` →
- * `'array'`) throughout the schema tree. Without this, `json-schema-to-zod`
- * emits a Zod union which the MCP SDK serialises back as `anyOf`, stripping
- * the concrete `type` from the output and breaking schema introspection.
- */
-export function sanitizeJsonSchema(schema: JSONSchema4): JSONSchema4 {
-  delete schema?.properties?.id
-  delete schema?.properties?.createdAt
-  delete schema?.properties?.updatedAt
-
-  if (Array.isArray(schema.required)) {
-    schema.required = schema.required.filter((field) => field !== 'id')
-    if (schema.required.length === 0) {
-      delete schema.required
-    }
-  }
-
-  if (schema.properties && typeof schema.properties === 'object') {
-    for (const key of Object.keys(schema.properties)) {
-      const prop = schema.properties[key] as JSONSchema4
-      if (!prop || typeof prop !== 'object') {
-        continue
-      }
-      normalizeNullableType(prop)
-      if (prop.properties) {
-        sanitizeJsonSchema(prop)
-      }
-      if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {
-        sanitizeJsonSchema(prop.items)
-      }
-    }
-  }
-
-  return schema
-}
-
-/**
- * Strips `'null'` from a `type` array only when the remaining type is a
- * complex structural type (`array` or `object`).
- *
- * Simple scalar types (`string`, `number`, `boolean`) are intentionally
- * preserved as `['string', 'null']` so that the MCP SDK serialises them as a
- * compact inline `type` array. Complex types however cause `zodToJsonSchema`
- * to emit `anyOf: [{ type: 'array', items: ... }, { type: 'null' }]`, which
- * has no top-level `type` property and breaks schema introspection by clients.
- */
-function normalizeNullableType(schema: JSONSchema4): void {
-  if (!Array.isArray(schema.type)) {
-    return
-  }
-  const nonNullTypes = schema.type.filter((t) => t !== 'null')
-  if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {
-    schema.type = nonNullTypes[0]
-  }
-}

package/src/utils/schemaConversion/simplifyRelationshipFields.ts

@@ -1,65 +0,0 @@
-import type { JSONSchema4 } from 'json-schema'
-
-/**
- * Recursively processes JSON schema properties to simplify relationship fields
- * and convert `oneOf` constructs into MCP-friendly schemas.
- *
- * For create/update validation we only need to accept IDs (string/number),
- * not populated objects. `$ref` options pointing to full entity definitions
- * are removed entirely from `oneOf` unions. When a single option remains the
- * `oneOf` is unwrapped; otherwise it is converted to `anyOf`.
- *
- * This matters because `json-schema-to-zod` converts `oneOf` into a strict
- * `z.any().superRefine(...)` validator whose base type is `z.any()`, causing
- * `zodToJsonSchema` to emit `{}` and losing all type information in the MCP
- * tool input schema. `anyOf` instead produces a clean `z.union([...])`.
- *
- * NOTE: This function must operate on a cloned schema to avoid mutating
- * the original JSON schema used for tool listing.
- */
-export function simplifyRelationshipFields(schema: JSONSchema4): JSONSchema4 {
-  if (!schema || typeof schema !== 'object') {
-    return schema
-  }
-
-  const processed = { ...schema }
-
-  if (Array.isArray(processed.oneOf)) {
-    const hasRef = processed.oneOf.some(
-      (option) => option && typeof option === 'object' && '$ref' in option,
-    )
-
-    if (hasRef) {
-      const nonRefOptions = processed.oneOf
-        .filter((option) => !(option && typeof option === 'object' && '$ref' in option))
-        .map((option) => simplifyRelationshipFields(option))
-
-      if (nonRefOptions.length === 1) {
-        const single = nonRefOptions[0]!
-        delete processed.oneOf
-        Object.assign(processed, single)
-      } else if (nonRefOptions.length > 1) {
-        delete processed.oneOf
-        processed.anyOf = nonRefOptions
-      }
-    } else {
-      processed.anyOf = processed.oneOf.map((option) => simplifyRelationshipFields(option))
-      delete processed.oneOf
-    }
-  }
-
-  if (processed.properties && typeof processed.properties === 'object') {
-    processed.properties = Object.fromEntries(
-      Object.entries(processed.properties).map(([key, value]) => [
-        key,
-        simplifyRelationshipFields(value),
-      ]),
-    )
-  }
-
-  if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {
-    processed.items = simplifyRelationshipFields(processed.items)
-  }
-
-  return processed
-}

package/src/utils/schemaConversion/transformPointFields.ts

@@ -1,55 +0,0 @@
-import type { JSONSchema4 } from 'json-schema'
-
-export function transformPointFieldsForMCP(schema: JSONSchema4): JSONSchema4 {
-  if (!schema || typeof schema !== 'object') {
-    return schema
-  }
-
-  const transformed = { ...schema }
-
-  if (transformed.properties && typeof transformed.properties === 'object') {
-    transformed.properties = Object.fromEntries(
-      Object.entries(transformed.properties).map(([key, value]) => {
-        const isArrayType =
-          value.type === 'array' || (Array.isArray(value.type) && value.type.includes('array'))
-
-        if (
-          value &&
-          typeof value === 'object' &&
-          isArrayType &&
-          Array.isArray(value.items) &&
-          value.items.length === 2 &&
-          value.items.every((item: JSONSchema4) => item?.type === 'number')
-        ) {
-          // Transform to object format
-          const isNullable = Array.isArray(value.type) && value.type.includes('null')
-
-          return [
-            key,
-            {
-              type: isNullable ? ['object', 'null'] : 'object',
-              description: value.description || 'Geographic coordinates (longitude, latitude)',
-              properties: {
-                latitude: { type: 'number', description: 'Latitude coordinate' },
-                longitude: { type: 'number', description: 'Longitude coordinate' },
-              },
-              required: ['longitude', 'latitude'],
-            },
-          ]
-        }
-
-        return [key, transformPointFieldsForMCP(value)]
-      }),
-    )
-  }
-
-  if (
-    transformed.items &&
-    typeof transformed.items === 'object' &&
-    !Array.isArray(transformed.items)
-  ) {
-    transformed.items = transformPointFieldsForMCP(transformed.items)
-  }
-
-  return transformed
-}