prisma-generator-express 1.67.0 → 1.69.0

package/src/generators/generateRouterPartsHono.ts

@@ -0,0 +1,220 @@
+import type { DMMF } from '@prisma/generator-helper'
+import { generateRouteConfigType } from './generateRouteConfigType'
+import type { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+import type { WriteStrategy } from '../constants'
+import { modelPathSegment, type PathCase } from '../utils/pathCasing'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+
+function opKindFor(opName: string): string {
+  switch (opName) {
+    case 'findUnique':
+    case 'findUniqueOrThrow':
+      return 'readUnique'
+    case 'findMany':
+    case 'findFirst':
+    case 'findFirstOrThrow':
+    case 'findManyPaginated':
+    case 'count':
+    case 'aggregate':
+    case 'groupBy':
+      return 'read'
+    case 'create':
+      return 'create'
+    case 'createMany':
+    case 'createManyAndReturn':
+      return 'createMany'
+    case 'update':
+      return 'update'
+    case 'updateMany':
+    case 'updateManyAndReturn':
+      return 'updateMany'
+    case 'upsert':
+      return 'upsert'
+    case 'delete':
+      return 'delete'
+    case 'deleteMany':
+      return 'deleteMany'
+    default:
+      return 'noop'
+  }
+}
+
+/**
+ * The phase 9 static assembly boundary, emitted side: one named factory per
+ * operation, each returning a Hono sub-app with exactly that route. A consumer
+ * imports only the parts it serves; everything not imported is absent from the
+ * bundle — which `enableAll` at runtime can never do, because route
+ * configuration is runtime data. Heavy features are referenced only by their
+ * own parts (`userOpenApi` is the sole static referencer of the OpenAPI
+ * renderer and `yaml`).
+ */
+export function generateHonoRouterParts({
+  model,
+  enums,
+  guardShapesImport,
+  clientImport,
+  importStyle,
+  writeStrategy,
+  dropGuard,
+  pathCase,
+}: {
+  model: DMMF.Model
+  enums: DMMF.DatamodelEnum[]
+  guardShapesImport: string | null
+  clientImport?: string
+  importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  dropGuard: boolean
+  pathCase: PathCase
+}): string {
+  const ext = importExt(importStyle)
+  const modelName = model.name
+  const modelSegment = modelPathSegment(modelName, pathCase)
+  const lower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
+  const cap = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
+
+  const handlerImports = OPERATION_METADATA.map(
+    (m) => `  ${modelName}${cap(m.name)},`,
+  ).join('\n')
+
+  const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
+  const writeOps = OPERATION_METADATA.filter(
+    (m) => m.kind === 'write' || m.kind === 'batch',
+  ).filter((m) => m.name !== 'updateEach')
+
+  const pathExpr = (suffix: string) =>
+    !suffix ? `setup.basePath || '/'` : `\`\${setup.basePath}${suffix}\``
+
+  const readFactories = readOps
+    .map((meta) => {
+      const fn = `${lower}${cap(meta.name)}`
+      const handler = `${modelName}${cap(meta.name)}`
+      const opKind = opKindFor(meta.name)
+      const pathValue = pathExpr(meta.pathSuffix)
+      const postPathValue =
+        meta.name === 'findMany'
+          ? `setup.basePath ? \`\${setup.basePath}/read\` : '/read'`
+          : pathExpr(meta.pathSuffix)
+      return `
+export function ${fn}<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const setup = ${lower}PartsSetup(config)
+  const opConfig = setup.opFor('${meta.configKey}')
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  app.get(${pathValue}, createReadRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handler}, parse: 'query', dropGuard: setup.dropGuard, settleBeforeHooks: setup.settleBeforeHooks }))
+  return app
+}
+
+export function ${fn}PostRead<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const setup = ${lower}PartsSetup(config)
+  const opConfig = setup.opFor('${meta.configKey}')
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  app.post(${postPathValue}, createReadRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handler}, parse: 'body', dropGuard: setup.dropGuard, settleBeforeHooks: setup.settleBeforeHooks }))
+  return app
+}
+`
+    })
+    .join('\n')
+
+  const writeFactories = writeOps
+    .map((meta) => {
+      const fn = `${lower}${cap(meta.name)}`
+      const handler = `${modelName}${cap(meta.name)}`
+      const opKind = opKindFor(meta.name)
+      const pathValue = pathExpr(meta.pathSuffix)
+      return `
+export function ${fn}<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const setup = ${lower}PartsSetup(config)
+  const opConfig = setup.opFor('${meta.configKey}')
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  app.${meta.method}(${pathValue}, createWriteRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handler}, dropGuard: setup.dropGuard, settleBeforeHooks: setup.settleBeforeHooks }))
+  return app
+}
+`
+    })
+    .join('\n')
+
+  return `import { Hono } from 'hono'
+import {
+${handlerImports}
+} from './${modelName}Handlers${ext}'
+import type {
+  RouteConfig,
+  HonoEnvBase,
+  GeneratedHonoEnv,
+  PrismaClientLike,
+} from '../routeConfig.target${ext}'
+import { normalizePrefix, getEnv, resolveDropGuardEnv } from '../misc${ext}'
+import {
+  resolveGuardPolicy,
+  validateCountSourceWhere,
+  warnIfUnguardedRoutes,
+} from '../routeConfig${ext}'
+import {
+  createReadRoute,
+  createWriteRoute,
+  createUpdateEachRoute,
+  opConfigFor,
+  normalizeHonoOperation,
+  type HonoOpConfig,
+} from '../routerParts${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
+
+${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono', clientImport)}
+
+// Fixed at generation time, identical to the legacy router factory.
+const DROP_GUARD = ${dropGuard}
+
+// No module-level side effects: this file must be tree-shakeable, so unused
+// per-op exports — and everything only they reference, down to the OpenAPI
+// renderer and yaml — drop out of a bundler's output. The environment is read
+// inside the functions that need it.
+
+function ${lower}PartsSetup<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv>) {
+  validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
+  validateCountSourceWhere(
+    (config.findManyPaginated && typeof config.findManyPaginated === 'object' ? config.findManyPaginated : undefined)?.pagination?.countSource,
+    '${modelName} findManyPaginated pagination',
+  )
+
+  const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
+  warnIfUnguardedRoutes('${modelName}', ['findMany', 'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow', 'findManyPaginated', 'count', 'aggregate', 'groupBy', 'create', 'createMany', 'createManyAndReturn', 'update', 'updateMany', 'updateManyAndReturn', 'upsert', 'delete', 'deleteMany'], config, isEnabled)
+
+  const customPrefix = normalizePrefix(config.customUrlPrefix || '')
+  const modelPrefix = config.addModelPrefix !== false ? '/${modelSegment}' : ''
+  const basePath = customPrefix + modelPrefix
+
+  const POLICY = resolveGuardPolicy(config)
+  const dropGuard =
+    DROP_GUARD || (POLICY.allowE2EGuardBypass && resolveDropGuardEnv(getEnv()))
+  const settleBeforeHooks = POLICY.guardResolutionOrder === 'before-hooks'
+
+  const opFor = <K extends keyof ${modelName}RouteConfig<TCtx, TPrisma, TEnv>>(
+    key: K,
+  ): HonoOpConfig<TEnv> => {
+    const raw = config[key] as unknown as Parameters<typeof normalizeHonoOperation<TEnv>>[0]
+    return opConfigFor<TEnv>(raw, '${modelName}.' + String(key), POLICY)
+  }
+
+  return { basePath, POLICY, dropGuard, settleBeforeHooks, opFor }
+}
+${readFactories}
+${writeFactories}
+export function ${lower}UpdateEach<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const setup = ${lower}PartsSetup(config)
+  if (!setup.POLICY.enableUpdateEach) {
+    throw new Error(
+      '${modelName}.updateEach: enableUpdateEach is false, so this part ' +
+      'is not available. It bypasses guard shapes entirely, so there is no ' +
+      'configuration that makes it safe to expose.',
+    )
+  }
+  const raw = config.updateEach as unknown as Parameters<typeof normalizeHonoOperation<TEnv>>[0]
+  const opConfig = normalizeHonoOperation<TEnv>(raw)
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  app.post(setup.basePath ? \`\${setup.basePath}/each\` : '/each', createUpdateEachRoute<TCtx, TPrisma, TEnv>({ config, opConfig, handler: ${modelName}UpdateEach, dropGuard: setup.dropGuard }))
+  return app
+}
+
+`
+}

package/src/generators/generateUnifiedHandler.ts

@@ -11,7 +11,6 @@ export interface UnifiedHandlerOptions {
 export function generateUnifiedHandler(options: UnifiedHandlerOptions): string {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
-
   const dispatchOps = OPERATION_METADATA.filter((m) => m.name !== 'updateEach')
 
   const handlers = dispatchOps
@@ -25,10 +24,25 @@ export async function ${exportName}(
   next: NextFunction,
 ) {
   try {
-    ;(res.locals as LocalsBag).data = await core.${meta.coreName}(buildContext(req, res))
+    const locals = readLocals(res)
+    ;locals.data = await executeOperation(
+      { variantKey: locals.guardVariantKey, caller: locals.guardCaller },
+      { guardShape: locals.guardShape },
+      {
+        core: core.${meta.coreName},
+        args: queryChannel(res),
+        body: req.body,
+        prisma: requirePrisma((req as ExtendedRequest).prisma),
+        postgres: (req as ExtendedRequest).postgres,
+        sqlite: (req as ExtendedRequest).sqlite,
+        pagination: locals.routeConfig?.pagination,
+        override: locals.operationOverride,
+        getContext: locals.getContext,
+      },
+    )
     next()
   } catch (error: unknown) {
-    next(mapError(error))
+    next(classifyError(error))
   }
 }`
     })
@@ -36,8 +50,14 @@ export async function ${exportName}(
 
   return `import type { Request, Response, NextFunction } from 'express'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext, RuntimeOperationOverride } from '../operationRuntime${ext}'
-import { mapError } from '../errorMapper${ext}'
+import type { RuntimeOperationOverride } from '../operationRuntime${ext}'
+import type { PaginationConfig } from '../routeConfig${ext}'
+import {
+  executeOperation,
+  classifyError,
+  requirePrisma,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 
 type ExtendedRequest = Request & {
   prisma?: unknown
@@ -47,30 +67,25 @@ type ExtendedRequest = Request & {
 
 type LocalsBag = {
   parsedQuery?: Record<string, unknown>
-  routeConfig?: { pagination?: unknown }
+  routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
   guardVariantKey?: string
   operationOverride?: RuntimeOperationOverride
-  resolveOperationContext?: () => unknown | Promise<unknown>
+  getContext?: () => Promise<unknown>
   data?: unknown
 }
 
-function buildContext(req: Request, res: Response): OperationContext {
-  const extReq = req as ExtendedRequest
-  const locals = res.locals as LocalsBag
+function readLocals(res: Response): LocalsBag {
+  return res.locals as LocalsBag
+}
+
+function queryChannel(res: Response): ArgsChannel {
   return {
-    operationOverride: locals.operationOverride,
-    resolveOperationContext: locals.resolveOperationContext,
-    prisma: extReq.prisma,
-    postgres: extReq.postgres,
-    sqlite: extReq.sqlite,
-    parsedQuery: locals.parsedQuery,
-    body: req.body,
-    guardShape: locals.guardShape,
-    guardCaller: locals.guardCaller,
-    guardVariantKey: locals.guardVariantKey,
-    paginationConfig: (locals.routeConfig?.pagination) as OperationContext['paginationConfig'],
+    read: () => readLocals(res).parsedQuery,
+    write: (next) => {
+      readLocals(res).parsedQuery = next
+    },
   }
 }
 ${handlers}

package/src/index.ts

@@ -33,6 +33,10 @@ import { generateHonoHandler } from './generators/generateHonoHandler'
 import { generateRouterFunction } from './generators/generateRouter'
 import { generateFastifyRouterFunction } from './generators/generateRouterFastify'
 import { generateHonoRouterFunction } from './generators/generateRouterHono'
+import { generateHonoRouterParts } from './generators/generateRouterPartsHono'
+import { generateHonoOpenApiRoutes } from './generators/generateHonoOpenApi'
+import { generateModelMcp } from './generators/generateModelMcp'
+import { generateMcpApp, generateMcpMount } from './generators/generateMcpApp'
 import { generateScalarUIHandler } from './generators/generateUnifiedScalarUI'
 import { generateUnifiedDocs } from './generators/generateUnifiedDocs'
 import { generateQueryBuilderHelper } from './generators/generateQueryBuilderHelper'
@@ -48,6 +52,10 @@ import {
   getGuardShapesImport,
 } from './generators/generateImportPrismaStatement'
 import { writeFileSafely } from './utils/writeFileSafely'
+import {
+  assertMcpGuardCompatibility,
+  assertMcpGuardVersion,
+} from './utils/mcpGate'
 import { copyFiles } from './utils/copyFiles'
 import { resolveImportStyle, ImportStyle } from './utils/resolveImportStyle'
 import { parsePathCase, modelPathSegment, PathCase } from './utils/pathCasing'
@@ -111,6 +119,26 @@ function getPathCase(options: GeneratorOptions): PathCase {
   )
 }
 
+function getMcp(options: GeneratorOptions): boolean {
+  const raw = (options.generator.config as Record<string, unknown>).mcp
+  if (raw === undefined || raw === null) return false
+  if (typeof raw === 'boolean') return raw
+  if (typeof raw === 'string') {
+    const lower = raw.trim().toLowerCase()
+    if (lower === 'true' || lower === '1' || lower === 'yes') return true
+    if (
+      lower === 'false' ||
+      lower === '0' ||
+      lower === 'no' ||
+      raw.trim() === ''
+    )
+      return false
+  }
+  throw new Error(
+    'Invalid mcp option "' + String(raw) + '". Expected true or false.',
+  )
+}
+
 function getDropGuard(options: GeneratorOptions): boolean {
   const raw = (options.generator.config as Record<string, unknown>).dropGuard
   if (raw === undefined || raw === null) return false
@@ -149,12 +177,26 @@ generatorHandler({
   },
 
   async onGenerate(options: GeneratorOptions) {
+    await runGenerate(options)
+  },
+})
+
+/**
+ * The full generation path, exported so tests exercise what `prisma generate`
+ * runs — including the mcp/dropGuard gate — instead of re-implementing pieces.
+ */
+export async function runGenerate(options: GeneratorOptions): Promise<void> {
+  {
     const target = getTarget(options)
     const writeStrategy = getWriteStrategy(options)
     const findManyPaginatedMode = getFindManyPaginatedMode(options)
     const dropGuard = getDropGuard(options)
+    const mcp = getMcp(options)
     const pathCase = getPathCase(options)
 
+    assertMcpGuardCompatibility(mcp, dropGuard)
+    assertMcpGuardVersion(mcp, options.schemaPath)
+
     const manifestDefaultAbs = path.resolve(
       __dirname,
       '..',
@@ -174,6 +216,7 @@ generatorHandler({
     const importStyle = resolveImportStyle(options)
 
     console.log(`\n═══ Prisma Generator (${target.toUpperCase()}) ═══`)
+    if (mcp) console.log(`  MCP: enabled (reads + opt-in writes)`)
     console.log(`  Target: ${target}`)
     console.log(`  Output: ${options.generator.output?.value}`)
     console.log(`  Import style: ${importStyle}`)
@@ -193,7 +236,7 @@ generatorHandler({
       validateClientGeneratorPresent(options)
     }
 
-    await copyFiles(options, target, importStyle)
+    await copyFiles(options, target, importStyle, mcp)
 
     const modelNames: string[] = []
     let guardArtifactsSeen = false
@@ -292,6 +335,38 @@ generatorHandler({
         operation: 'Router',
       })
 
+      if (target === 'hono') {
+        await writeFileSafely({
+          content: generateHonoRouterParts({
+            model: model as DMMF.Model,
+            enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
+            guardShapesImport,
+            clientImport: getRelativeClientTypeImport(options, model.name),
+            importStyle,
+            writeStrategy,
+            dropGuard,
+            pathCase,
+          }),
+          options,
+          model: model as DMMF.Model,
+          operation: 'RouterParts',
+        })
+        await writeFileSafely({
+          content: generateHonoOpenApiRoutes({
+            model: model as DMMF.Model,
+            enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
+            guardShapesImport,
+            clientImport: getRelativeClientTypeImport(options, model.name),
+            importStyle,
+            writeStrategy,
+            pathCase,
+          }),
+          options,
+          model: model as DMMF.Model,
+          operation: 'OpenApiRoutes',
+        })
+      }
+
       await writeFileSafely({
         content: generateScalarUIHandler({
           model: model as DMMF.Model,
@@ -327,6 +402,27 @@ generatorHandler({
       })
     }
 
+    if (mcp) {
+      // after the loop: each tool factory narrows schemas with THIS model's
+      // metadata plus the metadata of every model it relates to
+      for (const model of allModels) {
+        if (!modelNames.includes(model.name)) continue
+        await writeFileSafely({
+          content: generateModelMcp({
+            model,
+            allModels: allModels.filter((m) =>
+              modelNames.includes(m.name),
+            ) as DMMF.Model[],
+            importStyle,
+            writeStrategy,
+          }),
+          options,
+          model: model as DMMF.Model,
+          operation: 'Mcp',
+        })
+      }
+    }
+
     const pathSegments = Object.fromEntries(
       modelNames.map((n) => [n, modelPathSegment(n, pathCase)]),
     )
@@ -348,6 +444,23 @@ generatorHandler({
       operation: 'queryBuilder',
     })
 
+    if (mcp) {
+      await writeFileSafely({
+        content: generateMcpApp({
+          serverName: 'prisma-api',
+          serverVersion: require('../package.json').version,
+          importStyle,
+        }),
+        options,
+        operation: 'mcpApp',
+      })
+      await writeFileSafely({
+        content: generateMcpMount({ target, importStyle }),
+        options,
+        operation: 'mcpMount',
+      })
+    }
+
     if (modelNames.length > 0 && !guardArtifactsSeen) {
       console.log('')
       console.log(
@@ -361,5 +474,5 @@ generatorHandler({
     console.log('\n═══ Generation Complete ═══')
     console.log(`✓ ${modelNames.length} models (${target})`)
     console.log('')
-  },
-})
+  }
+}

package/src/utils/copyFiles.ts

@@ -9,10 +9,12 @@ const SHARED_FILES = [
   'parseQueryParams.ts',
   'buildModelOpenApi.ts',
   'operationDefinitions.ts',
+  'operationSchemas.ts',
   'misc.ts',
   'routeConfig.ts',
   'docsRenderer.ts',
   'operationRuntime.ts',
+  'operationPipeline.ts',
   'errorMapper.ts',
   'sse.ts',
   'pagination.ts',
@@ -126,6 +128,7 @@ export async function copyFiles(
   options: GeneratorOptions,
   target: Target,
   importStyle: ImportStyle,
+  mcp = false,
 ): Promise<void> {
   const outputPath = options.generator.output?.value
   if (!outputPath) return
@@ -153,6 +156,39 @@ export async function copyFiles(
     }
   }
 
+  if (target === 'hono') {
+    // The phase 9 assembly boundary. Imports the Hono route-config types by
+    // their source name; emitted as routeConfig.target.ts like every target.
+    const err = copyFileSync(
+      copyBase,
+      outputPath,
+      'routerParts.ts',
+      importStyle,
+      {
+        required: true,
+        importRewrites: [
+          { from: './routeConfig.hono', to: './routeConfig.target' },
+        ],
+      },
+    )
+    if (err) errors.push(err)
+  }
+
+  if (mcp) {
+    // MCP runtime is copied ONLY for mcp=true generations: an mcp=false
+    // output contains no MCP files, imports or dependencies at all.
+    const err = copyFileSync(
+      copyBase,
+      outputPath,
+      'mcpRuntime.ts',
+      importStyle,
+      {
+        required: true,
+      },
+    )
+    if (err) errors.push(err)
+  }
+
   const targetConfigFile = 'routeConfig.' + target + '.ts'
   const err = copyFileSync(
     copyBase,