prisma-generator-express 1.67.0 → 1.68.0

package/src/generators/generateFastifyHandler.ts

@@ -24,8 +24,24 @@ export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
 ): Promise<void> {
-  const data = await core.${meta.coreName}(buildContext(request))
-  ;(request as FastifyExtended).resultData = data
+  const fx = request as FastifyExtended
+  const data = await executeOperation(
+    { variantKey: fx.guardVariantKey, caller: fx.guardCaller },
+    { guardShape: fx.guardShape },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(request),
+      body: request.body,
+      prisma: requirePrisma(fx.prisma),
+      postgres: fx.postgres,
+      sqlite: fx.sqlite,
+      pagination: fx.routeConfig?.pagination,
+      override: fx.operationOverride,
+      getContext: fx.getContext,
+      findManyPaginatedMode: fx.findManyPaginatedMode,
+    },
+  )
+  fx.resultData = data
 }`
     })
     .join('\n')
@@ -38,10 +54,24 @@ export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
 ): Promise<void> {
-  const data = await core.${meta.coreName}(buildContext(request))
-  const ext = request as FastifyExtended
-  ext.resultData = data
-  ext.resultStatus = ${meta.successStatus}
+  const fx = request as FastifyExtended
+  const data = await executeOperation(
+    { variantKey: fx.guardVariantKey, caller: fx.guardCaller },
+    { guardShape: fx.guardShape },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(request),
+      body: request.body,
+      prisma: requirePrisma(fx.prisma),
+      postgres: fx.postgres,
+      sqlite: fx.sqlite,
+      pagination: fx.routeConfig?.pagination,
+      override: fx.operationOverride,
+      getContext: fx.getContext,
+    },
+  )
+  fx.resultData = data
+  fx.resultStatus = ${meta.successStatus}
 }`
     })
     .join('\n')
@@ -60,28 +90,44 @@ export async function ${updateEachExportName}(
   return `import type { FastifyRequest, FastifyReply } from 'fastify'
 import * as core from './${modelName}Core${ext}'
 import type { RuntimeOperationOverride, OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
+import type { PaginationConfig } from '../routeConfig${ext}'
+import {
+  executeOperation,
+  requirePrisma,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown
   postgres?: unknown
   sqlite?: unknown
   parsedQuery?: Record<string, unknown>
-  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
+  routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
   guardVariantKey?: string
   operationOverride?: RuntimeOperationOverride
-  resolveOperationContext?: () => unknown | Promise<unknown>
+  getContext?: () => Promise<unknown>
   findManyPaginatedMode?: FindManyPaginatedMode
   resultData?: unknown
   resultStatus?: number
 }
 
+function queryChannel(request: FastifyRequest): ArgsChannel {
+  const fx = request as FastifyExtended
+  return {
+    read: () => fx.parsedQuery,
+    write: (next) => {
+      fx.parsedQuery = next
+    },
+  }
+}
+
 function buildContext(request: FastifyRequest): OperationContext {
   const req = request as FastifyExtended
   return {
     operationOverride: req.operationOverride,
-    resolveOperationContext: req.resolveOperationContext,
+    resolveOperationContext: req.getContext,
     prisma: req.prisma,
     postgres: req.postgres,
     sqlite: req.sqlite,

package/src/generators/generateHonoHandler.ts

@@ -21,7 +21,21 @@ export function generateHonoHandler(options: {
       const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
       return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
-  const data = await core.${meta.coreName}(buildContext(c))
+  const data = await executeOperation(
+    { variantKey: c.get('guardVariantKey'), caller: c.get('guardCaller') },
+    { guardShape: c.get('guardShape') },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(c),
+      body: c.get('body'),
+      prisma: requirePrisma(c.get('prisma')),
+      postgres: c.get('postgres'),
+      sqlite: c.get('sqlite'),
+      pagination: c.get('routeConfig')?.pagination,
+      override: c.get('operationOverride'),
+      getContext: c.get('getContext'),
+    },
+  )
   c.set('resultData', data)
 }`
     })
@@ -32,7 +46,21 @@ export async function ${exportName}(c: HandlerContext): Promise<void> {
       const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
       return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
-  const data = await core.${meta.coreName}(buildContext(c))
+  const data = await executeOperation(
+    { variantKey: c.get('guardVariantKey'), caller: c.get('guardCaller') },
+    { guardShape: c.get('guardShape') },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(c),
+      body: c.get('body'),
+      prisma: requirePrisma(c.get('prisma')),
+      postgres: c.get('postgres'),
+      sqlite: c.get('sqlite'),
+      pagination: c.get('routeConfig')?.pagination,
+      override: c.get('operationOverride'),
+      getContext: c.get('getContext'),
+    },
+  )
   c.set('resultData', data)
   c.set('resultStatus', ${meta.successStatus})
 }`
@@ -49,15 +77,27 @@ export async function ${updateEachExportName}(c: HandlerContext): Promise<void>
 
   return `import type { Context } from 'hono'
 import * as core from './${modelName}Core${ext}'
-import type { RuntimeOperationOverride, OperationContext } from '../operationRuntime${ext}'
+import type { OperationContext } from '../operationRuntime${ext}'
+import {
+  executeOperation,
+  requirePrisma,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 import type { HonoInternalVariables } from '../routeConfig.target${ext}'
 
 type HandlerContext = Context<{ Variables: HonoInternalVariables }>
 
+function queryChannel(c: HandlerContext): ArgsChannel {
+  return {
+    read: () => c.get('parsedQuery'),
+    write: (next) => c.set('parsedQuery', next),
+  }
+}
+
 function buildContext(c: HandlerContext): OperationContext {
   return {
     operationOverride: c.get('operationOverride'),
-    resolveOperationContext: c.get('resolveOperationContext'),
+    resolveOperationContext: c.get('getContext'),
     prisma: c.get('prisma'),
     postgres: c.get('postgres'),
     sqlite: c.get('sqlite'),

package/src/generators/generateHonoOpenApi.ts

@@ -0,0 +1,93 @@
+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'
+
+/**
+ * The per-model OpenAPI part, in a module of its own so the phase 9 boundary
+ * holds by construction: a bundle that does not import this file has no path
+ * to `buildModelOpenApi` or `yaml`, regardless of bundler side-effect
+ * heuristics.
+ */
+export function generateHonoOpenApiRoutes({
+  model,
+  enums,
+  guardShapesImport,
+  clientImport,
+  importStyle,
+  writeStrategy,
+  pathCase,
+}: {
+  model: DMMF.Model
+  enums: DMMF.DatamodelEnum[]
+  guardShapesImport: string | null
+  clientImport?: string
+  importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  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)
+
+  return `import { Hono } from 'hono'
+import type {
+  RouteConfig,
+  HonoEnvBase,
+  GeneratedHonoEnv,
+  PrismaClientLike,
+} from '../routeConfig.target${ext}'
+import { normalizePrefix, getEnv } from '../misc${ext}'
+import { registerOpenApiRoutes } from '../routerParts${ext}'
+import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
+
+${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono', clientImport)}
+
+export function ${lower}OpenApi<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const _env = getEnv()
+  const customPrefix = normalizePrefix(config.customUrlPrefix || '')
+  const modelPrefix = config.addModelPrefix !== false ? '/${modelSegment}' : ''
+  const basePath = customPrefix + modelPrefix
+
+  const openApiDisabled = config.disableOpenApi === true
+    || (config.disableOpenApi !== false && (
+      _env.NODE_ENV === 'production'
+      || _env.DISABLE_OPENAPI === 'true'
+    ))
+
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  if (!openApiDisabled) {
+    let jsonCache: unknown = undefined
+    let yamlCache: string | undefined = undefined
+    registerOpenApiRoutes(app, basePath, () => {
+      if (jsonCache === undefined) {
+        jsonCache = buildModelOpenApi(
+          '${modelName}',
+          MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
+          MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
+          config as unknown as Parameters<typeof buildModelOpenApi>[3],
+          { format: 'json', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
+        )
+      }
+      return jsonCache
+    }, () => {
+      if (yamlCache === undefined) {
+        yamlCache = buildModelOpenApi(
+          '${modelName}',
+          MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
+          MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
+          config as unknown as Parameters<typeof buildModelOpenApi>[3],
+          { format: 'yaml', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
+        ) as string
+      }
+      return yamlCache
+    })
+  }
+  return app
+}
+`
+}

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

@@ -40,7 +40,7 @@ export function generateModelMetadata(
   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,
@@ -55,7 +55,7 @@ export function generateModelMetadata(
   }))
 
   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
@@ -66,7 +66,7 @@ export function generateModelMetadata(
     }))
 
   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)
@@ -77,16 +77,22 @@ export function generateModelMetadata(
     }
   }
 
+  // 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}'
@@ -95,9 +101,9 @@ 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)}
 `