prisma-generator-express 1.66.0 → 1.68.0

package/src/generators/generateImportPrismaStatement.ts

@@ -1,81 +1,93 @@
-import { GeneratorOptions } from '@prisma/generator-helper'
-import * as fs from 'fs'
-import path from 'path'
-
-function findClientGenerator(options: GeneratorOptions) {
-  const byName = options.otherGenerators.find((gen) => gen.name === 'client')
-  if (byName) return byName
-
-  const byProvider = options.otherGenerators.find(
-    (gen) =>
-      gen.provider.value === 'prisma-client-js' ||
-      gen.provider.value === '@prisma/client' ||
-      gen.provider.value === 'prisma-client',
-  )
-  return byProvider || null
-}
-
-function getRelativeImportPath(fromDir: string, clientOutputPath: string): string {
-  let relativeImportPath = path.relative(fromDir, clientOutputPath)
-  relativeImportPath = relativeImportPath.split(path.sep).join(path.posix.sep)
-  if (!relativeImportPath.startsWith('.')) {
-    relativeImportPath = './' + relativeImportPath
-  }
-  return relativeImportPath
-}
-
-export function getRelativeClientPath(
-  generatorOptions: GeneratorOptions,
-  modelName: string,
-): string {
-  const clientGenerator = findClientGenerator(generatorOptions)
-
-  if (!clientGenerator || !clientGenerator.output?.value) {
-    throw new Error(
-      'Prisma client generator not found. Ensure a generator block exists with name "client" or provider one of: prisma-client-js, @prisma/client, prisma-client.',
-    )
-  }
-
-  const outputValue = generatorOptions.generator.output?.value
-  if (!outputValue) {
-    throw new Error('Generator output path not defined.')
-  }
-
-  const routerDirPath = path.join(outputValue, modelName)
-
-  return getRelativeImportPath(routerDirPath, clientGenerator.output.value)
-}
-
-function findGuardGenerator(options: GeneratorOptions) {
-  const byProvider = options.otherGenerators.find(
-    (gen) =>
-      !!gen.provider?.value && gen.provider.value.includes('prisma-guard'),
-  )
-  if (byProvider) return byProvider
-
-  const byConfig = options.otherGenerators.find(
-    (gen) =>
-      !!gen.config &&
-      ('typedGuardShapes' in gen.config ||
-        'onInvalidZod' in gen.config ||
-        'findUniqueMode' in gen.config),
-  )
-  return byConfig || null
-}
-
-export function getGuardShapesImport(
-  options: GeneratorOptions,
-  modelName: string,
-): string | null {
-  const guard = findGuardGenerator(options)
-  if (!guard || !guard.output?.value) return null
-
-  if (guard.config?.typedGuardShapes === 'false') return null
-
-  const outputValue = options.generator.output?.value
-  if (!outputValue) return null
-
-  const fromDir = path.join(outputValue, modelName)
-  const shapesPath = path.join(guard.output.value, 'shapes')
-  return getRelativeImportPath(fromDir, shapesPath)
-}
+import { GeneratorOptions } from '@prisma/generator-helper'
+import * as fs from 'fs'
+import path from 'path'
+
+function findClientGenerator(options: GeneratorOptions) {
+  const byName = options.otherGenerators.find((gen) => gen.name === 'client')
+  if (byName) return byName
+
+  const byProvider = options.otherGenerators.find(
+    (gen) =>
+      gen.provider.value === 'prisma-client-js' ||
+      gen.provider.value === '@prisma/client' ||
+      gen.provider.value === 'prisma-client',
+  )
+  return byProvider || null
+}
+
+function getRelativeImportPath(
+  fromDir: string,
+  clientOutputPath: string,
+): string {
+  let relativeImportPath = path.relative(fromDir, clientOutputPath)
+  relativeImportPath = relativeImportPath.split(path.sep).join(path.posix.sep)
+  if (!relativeImportPath.startsWith('.')) {
+    relativeImportPath = './' + relativeImportPath
+  }
+  return relativeImportPath
+}
+
+export function getRelativeClientPath(
+  generatorOptions: GeneratorOptions,
+  modelName: string,
+): string {
+  const clientGenerator = findClientGenerator(generatorOptions)
+
+  if (!clientGenerator || !clientGenerator.output?.value) {
+    throw new Error(
+      'Prisma client generator not found. Ensure a generator block exists with name "client" or provider one of: prisma-client-js, @prisma/client, prisma-client.',
+    )
+  }
+
+  const outputValue = generatorOptions.generator.output?.value
+  if (!outputValue) {
+    throw new Error('Generator output path not defined.')
+  }
+
+  const routerDirPath = path.join(outputValue, modelName)
+
+  return getRelativeImportPath(routerDirPath, clientGenerator.output.value)
+}
+
+function findGuardGenerator(options: GeneratorOptions) {
+  const byProvider = options.otherGenerators.find(
+    (gen) =>
+      !!gen.provider?.value && gen.provider.value.includes('prisma-guard'),
+  )
+  if (byProvider) return byProvider
+
+  const byConfig = options.otherGenerators.find(
+    (gen) =>
+      !!gen.config &&
+      ('typedGuardShapes' in gen.config ||
+        'onInvalidZod' in gen.config ||
+        'findUniqueMode' in gen.config),
+  )
+  return byConfig || null
+}
+
+export function getGuardShapesImport(
+  options: GeneratorOptions,
+  modelName: string,
+): string | null {
+  const guard = findGuardGenerator(options)
+  if (!guard || !guard.output?.value) return null
+
+  if (guard.config?.typedGuardShapes === 'false') return null
+
+  const outputValue = options.generator.output?.value
+  if (!outputValue) return null
+
+  const fromDir = path.join(outputValue, modelName)
+  const shapesPath = path.join(guard.output.value, 'shapes')
+  return getRelativeImportPath(fromDir, shapesPath)
+}
+
+export function getRelativeClientTypeImport(
+  options: GeneratorOptions,
+  modelName: string,
+): string {
+  const client = findClientGenerator(options)
+  const entry = client?.provider.value === 'prisma-client' ? 'client' : 'index'
+  return getRelativeClientPath(options, modelName) + '/' + entry
+}

package/src/generators/generateMcpApp.ts

@@ -0,0 +1,133 @@
+import type { ImportStyle } from '../utils/resolveImportStyle'
+
+/**
+ * App-level MCP registry (emitted when generator option `mcp = true`),
+ * following the app-level `combinedDocs` / `queryBuilder` precedent.
+ */
+export function generateMcpApp({
+  serverName,
+  serverVersion,
+  importStyle,
+}: {
+  serverName: string
+  serverVersion: string
+  importStyle: ImportStyle
+}): string {
+  return `import type { McpServer } from '@modelcontextprotocol/server'
+import { registerMcpTools } from './mcpRuntime'
+import type { McpSharedOptions, McpToolContribution } from './mcpRuntime'
+
+export const MCP_SERVER_INFO = { name: ${JSON.stringify(serverName)}, version: ${JSON.stringify(serverVersion)} } as const
+
+export type McpRegisterOptions = McpSharedOptions & {
+  /** Explicit allowlist: only these model-operation tools are registered. */
+  tools: readonly McpToolContribution[]
+}
+
+/**
+ * Register the allowed MCP tools on a server instance. Call from the
+ * per-request server factory so \`authInfo\` is the verified principal for THIS
+ * request. Throws before registering anything when required options are
+ * missing, limits are invalid, or the guard is dropped in this environment.
+ */
+export function registerMcpToolsOnServer(
+  server: McpServer,
+  options: McpRegisterOptions,
+): void {
+  registerMcpTools(server, options)
+}
+`
+}
+
+/**
+ * Target-specific Streamable HTTP mount glue (emitted when `mcp = true`).
+ * One \`/mcp\` endpoint in the same process as the REST backend.
+ */
+export function generateMcpMount({
+  target,
+  importStyle,
+}: {
+  target: 'express' | 'fastify' | 'hono'
+  importStyle: ImportStyle
+}): string {
+  if (target === 'express') {
+    return `import type { RequestHandler } from 'express'
+import type { McpServer, AuthInfo } from '@modelcontextprotocol/server'
+import { createMcpHandler } from '@modelcontextprotocol/server'
+import { toNodeHandler } from '@modelcontextprotocol/node'
+
+/**
+ * Build the /mcp handler for Express. Authentication is YOUR middleware: put a
+ * verified AuthInfo on req.auth (e.g. requireBearerAuth from
+ * @modelcontextprotocol/express) before this handler runs. Without req.auth
+ * the request fails closed — registration refuses to run without a verified
+ * principal.
+ */
+export function createMcpExpressHandler(
+  getServer: (authInfo: AuthInfo) => McpServer,
+): RequestHandler {
+  const handler = createMcpHandler((ctx) => getServer(ctx.authInfo as AuthInfo))
+  const node = toNodeHandler(handler)
+  return (req, res) => void node(req, res, req.body)
+}
+`
+  }
+  if (target === 'fastify') {
+    return `import type { FastifyRequest, FastifyReply } from 'fastify'
+import type { McpServer, AuthInfo } from '@modelcontextprotocol/server'
+import { createMcpHandler } from '@modelcontextprotocol/server'
+import { toNodeHandler } from '@modelcontextprotocol/node'
+
+/**
+ * Build the /mcp handler for Fastify. Authentication is YOUR hook: attach the
+ * verified AuthInfo to request.raw.auth (onRequest) before this handler runs.
+ * Without it the request fails closed — registration refuses to run without a
+ * verified principal.
+ */
+export function createMcpFastifyHandler(
+  getServer: (authInfo: AuthInfo) => McpServer,
+): (request: FastifyRequest, reply: FastifyReply) => Promise<void> {
+  const handler = createMcpHandler((ctx) => getServer(ctx.authInfo as AuthInfo))
+  const node = toNodeHandler(handler)
+  return async (request, reply) => {
+    // The Node handler writes the response itself; without hijacking,
+    // Fastify would continue its own reply lifecycle after we return.
+    reply.hijack()
+    await node(request.raw, reply.raw, request.body)
+  }
+}
+`
+  }
+  return `import type { Context, Next } from 'hono'
+import type { McpServer, AuthInfo } from '@modelcontextprotocol/server'
+import { createMcpHandler } from '@modelcontextprotocol/server'
+
+/**
+ * Build the /mcp handler for Hono (web-standard). Authentication is YOUR
+ * middleware: verify the request and set c.set('authInfo', verified) before
+ * this handler runs — or use the web-standard requireBearerAuth gate from
+ * @modelcontextprotocol/server and pass its AuthInfo to fetch explicitly.
+ */
+export function createMcpHonoHandler(
+  getServer: (authInfo: AuthInfo) => McpServer,
+): (c: Context) => Promise<Response> {
+  const handler = createMcpHandler((ctx) => getServer(ctx.authInfo as AuthInfo))
+  return async (c: Context) => {
+    let parsedBody: unknown
+    try {
+      parsedBody = await c.req.json()
+    } catch {
+      parsedBody = undefined
+    }
+    const authInfo = c.get('authInfo') as AuthInfo | undefined
+    if (!authInfo) {
+      return Response.json(
+        { message: 'unauthenticated: a verified principal is required' },
+        { status: 401 },
+      )
+    }
+    return handler.fetch(c.req.raw, { parsedBody, authInfo })
+  }
+}
+`
+}

package/src/generators/generateModelMcp.ts

@@ -0,0 +1,208 @@
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+import type { WriteStrategy } from '../constants'
+
+const MCP_OPS = [
+  { name: 'findMany', coreName: 'findMany' },
+  { name: 'findUnique', coreName: 'findUnique' },
+  { name: 'findFirst', coreName: 'findFirst' },
+  { name: 'count', coreName: 'count' },
+  { name: 'findManyPaginated', coreName: 'findManyPaginated' },
+] as const
+
+/**
+ * Every guarded write op from the shared metadata. `updateEach` is excluded:
+ * it bypasses guard shapes, so it has no MCP factory.
+ */
+const MCP_WRITE_OPS = OPERATION_METADATA.filter(
+  (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+).map((m) => ({ name: m.name, coreName: m.coreName }))
+
+/** Matches MAX_PROJECTION_DEPTH in operationSchemas.ts. */
+const MAX_PROJECTION_DEPTH = 4
+
+/**
+ * The models reachable from `model` through relation fields, to the supported
+ * projection depth. Schema narrowing recurses into nested select/include
+ * trees through this set — a `User → Post → Comment` projection stays
+ * model-aware at `Comment` instead of degrading to an opaque object.
+ */
+function transitiveRelations(
+  model: DMMF.Model,
+  allModels: readonly DMMF.Model[],
+): string[] {
+  // allModels is the EMITTED model set: models turned off with
+  /// @generator off have no metadata file, so they are opaque here
+  const byName = new Map(allModels.map((m) => [m.name, m]))
+  const involved = new Set<string>([model.name])
+  let frontier = [model.name]
+  for (let depth = 0; depth < MAX_PROJECTION_DEPTH; depth++) {
+    const next: string[] = []
+    for (const name of frontier) {
+      const m = byName.get(name)
+      if (!m) continue
+      for (const field of m.fields) {
+        if (
+          field.kind === 'object' &&
+          byName.has(field.type) &&
+          !involved.has(field.type)
+        ) {
+          involved.add(field.type)
+          next.push(field.type)
+        }
+      }
+    }
+    if (next.length === 0) break
+    frontier = next
+  }
+  return [...involved].filter((n) => n !== model.name)
+}
+
+/**
+ * Per-model MCP tool factories: one named export per exposed operation (five
+ * reads plus every guarded write), each returning a
+ * `McpToolContribution` the application passes to `registerMcpTools`.
+ * Importing only the operations you expose is the same static assembly
+ * boundary the Hono parts use — unselected operations never enter the module
+ * graph, and write tools exist ONLY where application code imports them.
+ *
+ * Schema narrowing is model-aware and transitive: each tool carries this
+ * model's metadata plus the metadata of every model reachable through its
+ * relations (to the supported projection depth), so nested `select`/`include`
+ * trees stay narrowed at every level, with enum values available throughout.
+ */
+export function generateModelMcp({
+  model,
+  allModels,
+  importStyle,
+  writeStrategy,
+}: {
+  model: DMMF.Model
+  allModels: readonly DMMF.Model[]
+  importStyle: ImportStyle
+  /** Same value the operation cores were generated with. */
+  writeStrategy: WriteStrategy
+}): string {
+  const ext = importExt(importStyle)
+  const modelName = model.name
+  const lower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
+  const cap = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
+
+  const related = transitiveRelations(model, allModels)
+  // Model directories are keyed by the RAW model name for every target
+  // (writeFileSafely ignores pathCase for directories), so raw-name imports
+  // are correct under every pathCase configuration.
+  const relatedImports = related
+    .map(
+      (t) =>
+        `import { MODEL_FIELDS as ${t}Fields, MODEL_ENUMS as ${t}Enums, COMPOUND_ID as ${t}CompoundId, COMPOUND_UNIQUES as ${t}CompoundUniques } from '../${t}/${t}Metadata${ext}'`,
+    )
+    .join('\n')
+  const enumSets = [modelName, ...related]
+    .map(
+      (t) =>
+        `for (const e of ${t === modelName ? 'MODEL_ENUMS' : t + 'Enums'}) {
+  enums.set(e.name, e.values.map((v) => v.name))
+}`,
+    )
+    .join('\n')
+  const coreEntries = [modelName, ...related]
+    .map((t) => {
+      const fields = t === modelName ? 'MODEL_FIELDS' : t + 'Fields'
+      const compound =
+        t === modelName
+          ? 'compoundUniques'
+          : `(() => {
+  const list: Array<{ selector: string; fields: string[] }> = []
+  if (${t}CompoundId) {
+    list.push({ selector: ${t}CompoundId.selector, fields: [...${t}CompoundId.fields] })
+  }
+  for (const cu of ${t}CompoundUniques) {
+    list.push({ selector: cu.selector, fields: [...cu.fields] })
+  }
+  return list
+})()`
+      return `  ['${t}', {
+    name: '${t}',
+    fields: ${fields},
+    enums,
+    uniqueFields: ${fields}.filter((f) => f.isId || f.isUnique).map((f) => f.name),
+    compoundUniques: ${compound},
+  }]`
+    })
+    .join(',\n')
+
+  const writeNames = new Set(MCP_WRITE_OPS.map((op) => op.name))
+  const factories = [...MCP_OPS, ...MCP_WRITE_OPS]
+    .map(
+      (op) => `
+export function ${lower}${cap(op.name)}Tool<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike>(options: {
+  config: ${modelName}RouteConfig<TCtx, TPrisma>
+}): McpToolContribution {
+  return ${writeNames.has(op.name) ? 'createMcpWriteTool' : 'createMcpReadTool'}({
+    model: '${modelName}',
+    operation: '${op.name}',
+    config: options.config as unknown as Record<string, unknown>,
+    core: core.${op.coreName},
+    fields: MODEL_FIELDS,
+    enums: enums,
+    uniqueFields: MODEL_FIELDS.filter((f) => f.isId || f.isUnique).map(
+      (f) => f.name,
+    ),
+    compoundUniques: compoundUniques,
+    modelIndex: modelIndex,${
+      writeNames.has(op.name)
+        ? `
+    writeStrategy: '${writeStrategy}',`
+        : ''
+    }
+  })
+}
+`,
+    )
+    .join('\n')
+
+  return `import * as core from './${modelName}Core${ext}'
+import type { ${modelName}RouteConfig } from './${modelName}Router${ext}'
+import type { PrismaClientLike } from '../routeConfig.target${ext}'
+import {
+  createMcpReadTool,
+  createMcpWriteTool,
+  type McpToolContribution,
+  type SchemaModelMeta,
+} from '../mcpRuntime${ext}'
+import {
+  MODEL_FIELDS,
+  MODEL_ENUMS,
+  COMPOUND_ID,
+  COMPOUND_UNIQUES,
+} from './${modelName}Metadata${ext}'
+${relatedImports ? '\n' + relatedImports + '\n' : ''}
+// transitive relation metadata: narrowing recurses through these FULL model
+// metas — compound unique constraints (@@id / @@unique) ride along so nested
+// cursors and nested findUnique surfaces keep their unique selectors.
+const compoundUniques: Array<{ selector: string; fields: string[] }> = []
+if (COMPOUND_ID) {
+  compoundUniques.push({ selector: COMPOUND_ID.selector, fields: COMPOUND_ID.fields })
+}
+for (const cu of COMPOUND_UNIQUES) {
+  compoundUniques.push({ selector: cu.selector, fields: cu.fields })
+}
+
+const enums = new Map<string, readonly string[]>()
+${enumSets}
+
+// one shared, self-referential metadata index: every related model keeps
+// its full meta (compound uniques included) at every recursion depth
+const modelIndex = new Map<string, SchemaModelMeta>()
+const coreMetas: Array<[string, Omit<SchemaModelMeta, 'modelIndex'>]> = [
+${coreEntries},
+]
+for (const [name, core] of coreMetas) {
+  modelIndex.set(name, { ...core, modelIndex })
+}
+${factories}
+`
+}

package/src/generators/generateModelMetadata.ts

@@ -4,16 +4,26 @@ import { importExt } from '../utils/importExt'
 
 function exampleValueForType(fieldType: string): unknown {
   switch (fieldType) {
-    case 'String': return 'example'
-    case 'Int': return 1
-    case 'BigInt': return '1'
-    case 'Float': return 1.0
-    case 'Decimal': return '1.0'
-    case 'Boolean': return true
-    case 'DateTime': return '2025-01-01T00:00:00.000Z'
-    case 'Json': return {}
-    case 'Bytes': return 'base64data'
-    default: return 'example'
+    case 'String':
+      return 'example'
+    case 'Int':
+      return 1
+    case 'BigInt':
+      return '1'
+    case 'Float':
+      return 1.0
+    case 'Decimal':
+      return '1.0'
+    case 'Boolean':
+      return true
+    case 'DateTime':
+      return '2025-01-01T00:00:00.000Z'
+    case 'Json':
+      return {}
+    case 'Bytes':
+      return 'base64data'
+    default:
+      return 'example'
   }
 }
 
@@ -23,12 +33,14 @@ export interface GenerateModelMetadataOptions {
   importStyle: ImportStyle
 }
 
-export function generateModelMetadata(options: GenerateModelMetadataOptions): string {
+export function generateModelMetadata(
+  options: GenerateModelMetadataOptions,
+): string {
   const ext = importExt(options.importStyle)
   const { model, enums } = options
   const modelName = model.name
 
-  const fieldsMeta = model.fields.map((f: any) => ({
+  const fieldsMeta = model.fields.map((f) => ({
     name: f.name,
     kind: f.kind,
     type: f.type,
@@ -43,7 +55,7 @@ export function generateModelMetadata(options: GenerateModelMetadataOptions): st
   }))
 
   const referencedEnumTypes = new Set(
-    model.fields.filter((f: any) => f.kind === 'enum').map((f: any) => f.type),
+    model.fields.filter((f) => f.kind === 'enum').map((f) => f.type),
   )
 
   const enumsMeta = enums
@@ -54,7 +66,7 @@ export function generateModelMetadata(options: GenerateModelMetadataOptions): st
     }))
 
   const exampleValues: Record<string, unknown> = {}
-  for (const f of model.fields as any[]) {
+  for (const f of model.fields) {
     if (f.isId || f.isUnique || f.kind === 'scalar' || f.kind === 'enum') {
       if (f.kind === 'enum') {
         const enumDef = enums.find((e) => e.name === f.type)
@@ -65,16 +77,22 @@ export function generateModelMetadata(options: GenerateModelMetadataOptions): st
     }
   }
 
+  // the client-input selector key mirrors Prisma's WhereUniqueInput: the
+  // constraint's explicit name when given, else the fields joined with '_'
   const compoundId =
     model.primaryKey && model.primaryKey.fields.length > 1
-      ? { fields: model.primaryKey.fields }
+      ? {
+          selector: model.primaryKey.name || model.primaryKey.fields.join('_'),
+          fields: [...model.primaryKey.fields],
+        }
       : null
 
-  const compoundUniques = ((model as any).uniqueIndexes || [])
-    .filter((idx: any) => idx.fields && idx.fields.length > 1)
-    .map((idx: any) => ({
+  const compoundUniques = (model.uniqueIndexes ?? [])
+    .filter((idx) => idx.fields && idx.fields.length > 1)
+    .map((idx) => ({
       name: idx.name || idx.fields.join('_'),
-      fields: idx.fields,
+      selector: idx.name || idx.fields.join('_'),
+      fields: [...idx.fields],
     }))
 
   return `import type { FieldMeta, EnumMeta } from '../docsRenderer${ext}'
@@ -83,10 +101,10 @@ export const MODEL_FIELDS: FieldMeta[] = ${JSON.stringify(fieldsMeta, null, 2)}
 
 export const MODEL_ENUMS: EnumMeta[] = ${JSON.stringify(enumsMeta, null, 2)}
 
-export const COMPOUND_ID: { fields: string[] } | null = ${JSON.stringify(compoundId)}
+export const COMPOUND_ID: { selector: string; fields: string[] } | null = ${JSON.stringify(compoundId)}
 
-export const COMPOUND_UNIQUES: { name: string; fields: string[] }[] = ${JSON.stringify(compoundUniques)}
+export const COMPOUND_UNIQUES: { name: string; selector: string; fields: string[] }[] = ${JSON.stringify(compoundUniques)}
 
 export const EXAMPLE_VALUES: Record<string, unknown> = ${JSON.stringify(exampleValues, null, 2)}
 `
-}
+}