prisma-generator-express 1.66.0 → 1.68.0

package/src/index.ts

@@ -15,7 +15,11 @@ export {
   HARDENED_GUARD_PROFILE,
   resolveGuardPolicy,
 } from './guardOptions'
-export type { GuardPolicy, GuardOptionMetadata, GuardResolutionOrder } from './guardOptions'
+export type {
+  GuardPolicy,
+  GuardOptionMetadata,
+  GuardResolutionOrder,
+} from './guardOptions'
 
 import {
   generatorHandler,
@@ -29,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'
@@ -40,11 +48,17 @@ import {
 import { generateModelMetadata } from './generators/generateModelMetadata'
 import {
   getRelativeClientPath,
+  getRelativeClientTypeImport,
   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'
 import {
   GENERATOR_NAME,
   Target,
@@ -99,6 +113,32 @@ function getFindManyPaginatedMode(
   )
 }
 
+function getPathCase(options: GeneratorOptions): PathCase {
+  return parsePathCase(
+    (options.generator.config as Record<string, unknown>).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
@@ -109,7 +149,8 @@ function getDropGuard(options: GeneratorOptions): boolean {
     const s = raw.trim()
     const lower = s.toLowerCase()
     if (lower === 'true' || lower === '1' || lower === 'yes') return true
-    if (lower === 'false' || lower === '0' || lower === 'no' || s === '') return false
+    if (lower === 'false' || lower === '0' || lower === 'no' || s === '')
+      return false
     const envVal = process.env[s]
     if (envVal === undefined) return false
     const el = envVal.trim().toLowerCase()
@@ -136,10 +177,25 @@ 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,
@@ -160,11 +216,13 @@ 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}`)
     console.log(`  Write strategy: ${writeStrategy}`)
     console.log(`  findManyPaginated mode: ${findManyPaginatedMode}`)
+    console.log(`  Path case: ${pathCase}`)
 
     if (dropGuard) {
       console.log('')
@@ -178,9 +236,10 @@ generatorHandler({
       validateClientGeneratorPresent(options)
     }
 
-    await copyFiles(options, target, importStyle)
+    await copyFiles(options, target, importStyle, mcp)
 
     const modelNames: string[] = []
+    let guardArtifactsSeen = false
     const generateHandler: (opts: {
       model: DMMF.Model
       importStyle: ImportStyle
@@ -201,6 +260,7 @@ generatorHandler({
       modelNames.push(model.name)
 
       const guardShapesImport = getGuardShapesImport(options, model.name)
+      if (guardShapesImport) guardArtifactsSeen = true
 
       await writeFileSafely({
         content: generateModelMetadata({
@@ -238,28 +298,34 @@ generatorHandler({
               model: model as DMMF.Model,
               enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
               guardShapesImport,
+              clientImport: getRelativeClientTypeImport(options, model.name),
               importStyle,
               writeStrategy,
               findManyPaginatedMode,
               dropGuard,
+              pathCase,
             })
           : target === 'hono'
             ? generateHonoRouterFunction({
                 model: model as DMMF.Model,
                 enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
                 guardShapesImport,
+                clientImport: getRelativeClientTypeImport(options, model.name),
                 importStyle,
                 writeStrategy,
                 dropGuard,
+                pathCase,
               })
             : generateRouterFunction({
                 model: model as DMMF.Model,
                 enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
                 guardShapesImport,
+                clientImport: getRelativeClientTypeImport(options, model.name),
                 importStyle,
                 writeStrategy,
                 findManyPaginatedMode,
                 dropGuard,
+                pathCase,
               })
 
       await writeFileSafely({
@@ -269,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,
@@ -304,8 +402,38 @@ 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)]),
+    )
+
     await writeFileSafely({
-      content: generateUnifiedDocs(modelNames, target, importStyle),
+      content: generateUnifiedDocs(
+        modelNames,
+        pathSegments,
+        target,
+        importStyle,
+      ),
       options,
       operation: 'combinedDocs',
     })
@@ -316,8 +444,35 @@ 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(
+        '  Note: prisma-guard not detected. Generated routes call Prisma directly',
+      )
+      console.log(
+        '  unless your route configs define guard shapes or variants.',
+      )
+    }
+
     console.log('\n═══ Generation Complete ═══')
     console.log(`✓ ${modelNames.length} models (${target})`)
     console.log('')
-  },
-})
+  }
+}