prisma-generator-express 1.65.2 → 1.67.0

package/src/generators/generateRouterHono.ts

@@ -1,8 +1,9 @@
-import { DMMF } from '@prisma/generator-helper'
+import type { DMMF } from '@prisma/generator-helper'
 import { generateRouteConfigType } from './generateRouteConfigType'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
-import { WriteStrategy } from '../constants'
+import type { WriteStrategy } from '../constants'
+import { modelPathSegment, type PathCase } from '../utils/pathCasing'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
 function pathExpr(suffix: string): string {
@@ -44,7 +45,10 @@ function opKindFor(opName: string): string {
   }
 }
 
-function emitReadOp(meta: (typeof OPERATION_METADATA)[number], modelName: string): string {
+function emitReadOp(
+  meta: (typeof OPERATION_METADATA)[number],
+  modelName: string,
+): string {
   const c = meta.name.charAt(0).toUpperCase() + meta.name.slice(1)
   const handlerName = `${modelName}${c}`
   const pathValue = pathExpr(meta.pathSuffix)
@@ -52,11 +56,11 @@ function emitReadOp(meta: (typeof OPERATION_METADATA)[number], modelName: string
 
   const postReadLine = meta.supportsPostRead
     ? meta.name === 'findMany'
-      ? `    if (postReadsEnabled) {
+      ? `    if (resolvePostReadsEnabled(config.disablePostReads, opConfig.disablePostReads)) {
       const postPath = basePath ? \`\${basePath}/read\` : '/read'
       app.post(postPath, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware, '${opKind}'))
     }`
-      : `    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware, '${opKind}'))`
+      : `    if (resolvePostReadsEnabled(config.disablePostReads, opConfig.disablePostReads)) app.post(path, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware, '${opKind}'))`
     : ''
 
   return `  if (isEnabled(config.${meta.configKey})) {
@@ -67,7 +71,10 @@ ${postReadLine}
   }`
 }
 
-function emitWriteOp(meta: (typeof OPERATION_METADATA)[number], modelName: string): string {
+function emitWriteOp(
+  meta: (typeof OPERATION_METADATA)[number],
+  modelName: string,
+): string {
   const c = meta.name.charAt(0).toUpperCase() + meta.name.slice(1)
   const handlerName = `${modelName}${c}`
   const pathValue = pathExpr(meta.pathSuffix)
@@ -96,7 +103,7 @@ function emitWriteOp(meta: (typeof OPERATION_METADATA)[number], modelName: strin
  *   - `requireDefaultVariantOptIn`  confirm a `default` variant
  *   - `enableUpdateEach`            register the batch route (default true)
  *   - `guardResolutionOrder`        settle the guard before or after hooks
- *   - `allowE2EGuardBypass`         honour E2E=true (default true)
+ *   - `allowE2EGuardBypass`         honour PGE_DROP_GUARD=true (default true)
  *   - `validateResolvedShapes`      check what a shape function returned
  *
  * `HARDENED_GUARD_PROFILE` selects all seven, as values to spread rather than a
@@ -106,7 +113,10 @@ function emitWriteOp(meta: (typeof OPERATION_METADATA)[number], modelName: strin
  *
  * The emitted router used to compute `DROP_GUARD = <flag> || _env.E2E === 'true'`,
  * so setting `E2E=true` in a deployed environment downgraded enforcement even
- * when the generator had been told to keep the guard. The two modes are not
+ * when the generator had been told to keep the guard. The bypass now lives once
+ * in the shared runtime as `resolveDropGuardEnv`: it honours `PGE_DROP_GUARD=true`
+ * and keeps `E2E=true` working as a deprecated alias with a one-time warning.
+ * The two modes are not
  * equivalent: with the guard, the shape goes to prisma-guard; with it dropped,
  * `applyDroppedGuard` applies projection defaults and forced `where` clauses and
  * nothing else is validated against the shape.
@@ -133,32 +143,39 @@ export function generateHonoRouterFunction({
   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 modelNameLower = modelName.toLowerCase()
+  const modelSegment = modelPathSegment(modelName, pathCase)
   const routerFunctionName = `${modelName}Router`
 
-  const handlerImports = OPERATION_METADATA
-    .map((m) => `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`)
-    .join('\n')
+  const handlerImports = OPERATION_METADATA.map(
+    (m) => `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`,
+  ).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 writeOps = OPERATION_METADATA.filter(
+    (m) => m.kind === 'write' || m.kind === 'batch',
+  ).filter((m) => m.name !== 'updateEach')
 
   const readOpBlocks = readOps.map((m) => emitReadOp(m, modelName)).join('\n\n')
-  const writeOpBlocks = writeOps.map((m) => emitWriteOp(m, modelName)).join('\n\n')
+  const writeOpBlocks = writeOps
+    .map((m) => emitWriteOp(m, modelName))
+    .join('\n\n')
 
   return `import { Hono } from 'hono'
 import type { Context } from 'hono'
@@ -175,9 +192,10 @@ import type {
   HonoInternalVariables,
   GeneratedHonoEnv,
   PaginationConfig,
+  PrismaClientLike,
 } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
-import { normalizePrefix, getEnv, sanitizeKeys, isPlainObject } from '../misc${ext}'
+import { normalizePrefix, getEnv, sanitizeKeys, isPlainObject, resolveDropGuardEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import {
   normalizeOperation,
@@ -187,7 +205,10 @@ import {
   validateCountSourceWhere,
   validateOperationConfig,
   validateUpdateEachConfig,
+  resolvePostReadsEnabled,
+  warnIfUnguardedRoutes,
 } from '../routeConfig${ext}'
+import type { RuntimeOperationOverride } from '../operationRuntime${ext}'
 import type { NormalizedOperationConfig } from '../routeConfig${ext}'
 import { transformResult } from '../operationRuntime${ext}'
 import { mapError } from '../errorMapper${ext}'
@@ -197,7 +218,7 @@ import { applyDroppedGuard } from '../projectionDefaults${ext}'
 import type { OpKind } from '../projectionDefaults${ext}'
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
-${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono')}
+${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono', clientImport)}
 const _env = getEnv()
 
 // Fixed at generation time. The \`allowE2EGuardBypass\` control decides whether the
@@ -205,15 +226,19 @@ const _env = getEnv()
 // which is upstream behaviour. See generateRouterHono.ts.
 const DROP_GUARD = ${dropGuard}
 
-type JsonLike =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonLike[]
-  | { [k: string]: JsonLike }
+/**
+ * DELIBERATELY NOT RECURSIVE.
+ *
+ * A self-referential JSON type sent through \`c.json()\` makes Hono's response
+ * inference instantiate without a fixed point, and TypeScript answers
+ * "type instantiation is excessively deep" — in the emitted file, for every
+ * consumer. One level is all this needs: the value is serialised, not walked.
+ */
+type JsonLike = string | number | boolean | null | unknown[] | Record<string, unknown>
 
 type OperationConfigLike<TEnv extends HonoEnvBase> = {
+  authorize?: HonoBeforeHook<TEnv>
+  override?: RuntimeOperationOverride
   before?: HonoBeforeHook<TEnv>[]
   after?: HonoAfterHook<TEnv>[]
   shape?: unknown
@@ -287,7 +312,7 @@ async function parseWriteBodyMiddleware(c: HandlerContext): Promise<void> {
   c.set('body', body)
 }
 
-function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
+function makeShapeMiddleware<TCtx, TPrisma extends PrismaClientLike, TEnv extends HonoEnvBase>(
   config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv>,
   opConfig: NormalizedOp<TEnv>,
   opKind: OpKind,
@@ -297,24 +322,40 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
   /**
    * The environment bypass, honoured unless the consumer turned it off.
    *
-   * \`E2E=true\` downgrading enforcement in a deployed environment is a real
-   * hazard, and it is also upstream behaviour — so it is a control, not a
-   * decision made here.
+   * \`PGE_DROP_GUARD=true\` downgrading enforcement in a deployed environment is
+   * a real hazard, and it is also upstream behaviour (under its deprecated
+   * \`E2E=true\` spelling) — so it is a control, not a decision made here.
    */
-  const dropGuard = DROP_GUARD || (policy.allowE2EGuardBypass && _env.E2E === 'true')
+  const dropGuard = DROP_GUARD || (policy.allowE2EGuardBypass && resolveDropGuardEnv(_env))
 
   return async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<void> => {
+    /**
+     * INTERNAL REQUEST STATE IS SET THROUGH A CONCRETE CONTEXT.
+     *
+     * \`GeneratedHonoEnv<TEnv>['Variables']\` is \`HonoInternalVariables & TEnv['Variables']\`,
+     * and inside this generic function TypeScript cannot know that the consumer's
+     * half does not also declare \`routeConfig\` — so setting that key straight
+     * onto \`c\` is unassignable to the intersection and the emitted router does not
+     * typecheck under \`strict\` for ANY consumer. These keys belong to this
+     * router, so they are written through the internal shape they were declared
+     * in.
+     */
+    const vars = c as unknown as HandlerContext
+    vars.set('operationOverride', opConfig.override)
+    let context: Promise<unknown> | undefined
+    vars.set('resolveOperationContext', () => context ??= Promise.resolve(config.resolveContext?.(c)))
+
     const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
-    if (merged) c.set('routeConfig', { pagination: merged })
+    if (merged) vars.set('routeConfig', { pagination: merged })
 
     const headerName = config.guard?.variantHeader || 'x-api-variant'
     const headerValue = c.req.header(headerName)
     const caller = config.guard?.resolveVariant?.(c) ?? headerValue ?? undefined
-    if (typeof caller === 'string') c.set('guardCaller', caller)
+    if (typeof caller === 'string') vars.set('guardCaller', caller)
 
     const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
     if (!resolution.ok) {
-      c.set('guardVariantFailure', resolution)
+      vars.set('guardVariantFailure', resolution)
       return
     }
 
@@ -322,11 +363,11 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
       opConfig.guardRouting.kind === 'named'
         ? resolution.key
         : undefined
-    if (resolvedKey !== undefined) c.set('guardVariantKey', resolvedKey)
+    if (resolvedKey !== undefined) vars.set('guardVariantKey', resolvedKey)
 
     if (opConfig.guardShape) {
       const resolveCtx = typeof config.resolveContext === 'function'
-        ? () => (config.resolveContext as (ctx: Context<GeneratedHonoEnv<TEnv>>) => unknown | Promise<unknown>)(c)
+        ? vars.get('resolveOperationContext')
         : undefined
 
       /**
@@ -339,18 +380,20 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
        * behaviour: it is resolved at the point of use, and a function returning
        * something unusable is not this router's business to refuse.
        */
-      let effectiveShape: unknown = opConfig.guardShape
+      let effectiveShape: Record<string, unknown> | undefined = opConfig.guardShape
       if (policy.validateResolvedShapes) {
         const resolution = await resolveGuardShapeOnce(opConfig.guardShape, resolvedKey, resolveCtx)
         if (!resolution.ok) {
-          c.set('guardShapeFailure', resolution.problem)
+          vars.set('guardShapeFailure', resolution.problem)
           return
         }
-        effectiveShape = resolution.shape
+        // \`ok\` means the resolved value is a shape object; the fallback keeps the
+        // declared shape rather than storing something the context cannot hold.
+        effectiveShape = isPlainObject(resolution.shape) ? resolution.shape : opConfig.guardShape
       }
 
       if (!dropGuard) {
-        c.set('guardShape', effectiveShape)
+        vars.set('guardShape', effectiveShape)
       } else {
         await applyDroppedGuard(
           effectiveShape,
@@ -358,24 +401,24 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
           resolveCtx,
           opKind,
           {
-            readQuery: c.get('parsedQuery'),
-            writeBody: isPlainObject(c.get('body'))
-              ? (c.get('body') as Record<string, unknown>)
+            readQuery: vars.get('parsedQuery'),
+            writeBody: isPlainObject(vars.get('body'))
+              ? (vars.get('body') as Record<string, unknown>)
               : undefined,
           },
           () => {
-            let target = c.get('parsedQuery')
+            let target = vars.get('parsedQuery')
             if (!target) {
               target = {}
-              c.set('parsedQuery', target)
+              vars.set('parsedQuery', target)
             }
             return target
           },
           () => {
-            let target = c.get('body')
+            let target = vars.get('body')
             if (!isPlainObject(target)) {
               target = {}
-              c.set('body', target)
+              vars.set('body', target)
             }
             return target as Record<string, unknown>
           },
@@ -424,7 +467,7 @@ function sendError(c: HandlerContext, error: unknown): Response {
   return c.json({ message: httpError.message }, httpError.status as ContentfulStatusCode)
 }
 
-export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
   validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
   validateCountSourceWhere(
     (config.findManyPaginated && typeof config.findManyPaginated === 'object' ? config.findManyPaginated : undefined)?.pagination?.countSource,
@@ -434,9 +477,10 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
   const app = new Hono<GeneratedHonoEnv<TEnv>>()
 
   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 ? '/${modelNameLower}' : ''
+    const modelPrefix = config.addModelPrefix !== false ? '/${modelSegment}' : ''
   const basePath = customPrefix + modelPrefix
 
   const openApiDisabled = config.disableOpenApi === true
@@ -445,7 +489,6 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       || _env.DISABLE_OPENAPI === 'true'
     ))
 
-  const postReadsEnabled = !config.disablePostReads
 
   let _openApiJsonCache: unknown = undefined
   const getOpenApiJson = (): unknown => {
@@ -454,8 +497,8 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
         '${modelName}',
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
-        config as RouteConfig,
-        { format: 'json', writeStrategy: '${writeStrategy}' },
+        config as unknown as Parameters<typeof buildModelOpenApi>[3],
+        { format: 'json', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
       )
     }
     return _openApiJsonCache
@@ -467,14 +510,14 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
         '${modelName}',
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
-        config as RouteConfig,
-        { format: 'yaml', writeStrategy: '${writeStrategy}' },
+        config as unknown as Parameters<typeof buildModelOpenApi>[3],
+        { format: 'yaml', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
       ) as string
     }
     return _openApiYamlCache
   }
 
-  if (config.queryBuilder && config.queryBuilder !== false && _env.NODE_ENV !== 'production') {
+  if (config.queryBuilder && _env.NODE_ENV !== 'production') {
     console.warn(
       '[${modelName}Router] queryBuilder config is present but Hono target does not auto-start it. ' +
       'Run \`npx prisma-query-builder-ui\` in a separate process.',
@@ -482,7 +525,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
   }
 
   app.onError((err, c) => {
-    return sendError(c as HandlerContext, err)
+    return sendError(c as unknown as HandlerContext, err)
   })
 
   if (!openApiDisabled) {
@@ -512,14 +555,15 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
    * that branch is inert rather than merely unreached when it is off.
    */
   const settleGuard = (c: Context<GeneratedHonoEnv<TEnv>>): void => {
-    const failure = c.get('guardVariantFailure')
+    const vars = c as unknown as HandlerContext
+    const failure = vars.get('guardVariantFailure')
     if (failure) {
       throw new HTTPException(400, {
         message: formatGuardVariantResolutionError(failure),
       })
     }
 
-    const shapeFailure = c.get('guardShapeFailure')
+    const shapeFailure = vars.get('guardShapeFailure')
     if (shapeFailure) {
       throw new HTTPException(500, {
         message: 'guard shape could not be resolved: ' + shapeFailure,
@@ -534,6 +578,8 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
     opKind: OpKind,
   ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
     try {
+      const authorized = await runBeforeHooks<TEnv>(opConfig.authorize ? [opConfig.authorize] : [], c)
+      if (authorized) return authorized
       await parseFn(c as unknown as HandlerContext)
       await makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig, opKind)(c)
 
@@ -546,7 +592,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       // Upstream order: hooks first, guard failure after.
       if (!SETTLE_BEFORE_HOOKS) settleGuard(c)
 
-      const key = c.get('guardVariantKey')
+      const key = (c as unknown as HandlerContext).get('guardVariantKey')
       const variantHooks =
         key !== undefined ? opConfig.variantHooks[key] : undefined
 
@@ -569,6 +615,8 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
     opKind: OpKind,
   ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
     try {
+      const authorized = await runBeforeHooks<TEnv>(opConfig.authorize ? [opConfig.authorize] : [], c)
+      if (authorized) return authorized
       await parseWriteBodyMiddleware(c as unknown as HandlerContext)
       await makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig, opKind)(c)
 
@@ -581,7 +629,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       // Upstream order: hooks first, guard failure after.
       if (!SETTLE_BEFORE_HOOKS) settleGuard(c)
 
-      const key = c.get('guardVariantKey')
+      const key = (c as unknown as HandlerContext).get('guardVariantKey')
       const variantHooks =
         key !== undefined ? opConfig.variantHooks[key] : undefined
 
@@ -659,4 +707,4 @@ ${writeOpBlocks}
   return app
 }
 `
-}
+}

package/src/generators/generateUnifiedDocs.ts

@@ -4,18 +4,21 @@ import type { Target } from '../constants'
 
 export function generateUnifiedDocs(
   modelNames: string[],
+  pathSegments: Record<string, string>,
   target: Target,
   importStyle: ImportStyle,
 ): string {
   const ext = importExt(importStyle)
-  if (target === 'fastify') return generateFastify(modelNames, ext)
-  if (target === 'hono') return generateHono(modelNames, ext)
-  return generateExpress(modelNames, ext)
+  if (target === 'fastify')
+    return generateFastify(modelNames, pathSegments, ext)
+  if (target === 'hono') return generateHono(modelNames, pathSegments, ext)
+  return generateExpress(modelNames, pathSegments, ext)
 }
 
 const renderIndexFn = `function renderIndex(title: string, modelNames: string[], basePath: string): string {
+  const segments = MODEL_PATH_SEGMENTS as Record<string, string>
   const links = modelNames
-    .map((n) => '<li><a href="' + basePath + '/' + n.toLowerCase() + '">' + n + '</a></li>')
+    .map((n) => '<li><a href="' + basePath + '/' + (segments[n] ?? n.toLowerCase()) + '">' + n + '</a></li>')
     .join('')
 
   return '<!DOCTYPE html><html><head><meta charset="utf-8" /><title>' + title +
@@ -27,7 +30,11 @@ const renderIndexFn = `function renderIndex(title: string, modelNames: string[],
     '</div></body></html>'
 }`
 
-function generateExpress(modelNames: string[], ext: string): string {
+function generateExpress(
+  modelNames: string[],
+  pathSegments: Record<string, string>,
+  ext: string,
+): string {
   return `import type { Router } from 'express'
 import { getEnv, removeTrailingSlash } from './misc${ext}'
 
@@ -35,6 +42,8 @@ const _env = getEnv()
 
 const MODELS = ${JSON.stringify(modelNames)} as const
 
+const MODEL_PATH_SEGMENTS = ${JSON.stringify(pathSegments)} as const
+
 interface UnifiedDocsConfig {
   title?: string
   basePath?: string
@@ -62,7 +71,11 @@ export default registerUnifiedDocs
 `
 }
 
-function generateFastify(modelNames: string[], ext: string): string {
+function generateFastify(
+  modelNames: string[],
+  pathSegments: Record<string, string>,
+  ext: string,
+): string {
   return `import type { FastifyInstance } from 'fastify'
 import { getEnv, removeTrailingSlash } from './misc${ext}'
 
@@ -70,6 +83,8 @@ const _env = getEnv()
 
 const MODELS = ${JSON.stringify(modelNames)} as const
 
+const MODEL_PATH_SEGMENTS = ${JSON.stringify(pathSegments)} as const
+
 interface UnifiedDocsConfig {
   title?: string
   basePath?: string
@@ -100,7 +115,11 @@ export default registerUnifiedDocs
 `
 }
 
-function generateHono(modelNames: string[], ext: string): string {
+function generateHono(
+  modelNames: string[],
+  pathSegments: Record<string, string>,
+  ext: string,
+): string {
   return `import type { Hono } from 'hono'
 import { getEnv, removeTrailingSlash } from './misc${ext}'
 
@@ -108,6 +127,8 @@ const _env = getEnv()
 
 const MODELS = ${JSON.stringify(modelNames)} as const
 
+const MODEL_PATH_SEGMENTS = ${JSON.stringify(pathSegments)} as const
+
 interface UnifiedDocsConfig {
   title?: string
   basePath?: string
@@ -133,4 +154,4 @@ ${renderIndexFn}
 
 export default registerUnifiedDocs
 `
-}
+}

package/src/generators/generateUnifiedHandler.ts

@@ -1,5 +1,5 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
@@ -14,10 +14,11 @@ export function generateUnifiedHandler(options: UnifiedHandlerOptions): string {
 
   const dispatchOps = OPERATION_METADATA.filter((m) => m.name !== 'updateEach')
 
-  const handlers = dispatchOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
+  const handlers = dispatchOps
+    .map((meta) => {
+      const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
 
-    return `
+      return `
 export async function ${exportName}(
   req: Request,
   res: Response,
@@ -30,11 +31,12 @@ export async function ${exportName}(
     next(mapError(error))
   }
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
   return `import type { Request, Response, NextFunction } from 'express'
 import * as core from './${modelName}Core${ext}'
-import { OperationContext } from '../operationRuntime${ext}'
+import type { OperationContext, RuntimeOperationOverride } from '../operationRuntime${ext}'
 import { mapError } from '../errorMapper${ext}'
 
 type ExtendedRequest = Request & {
@@ -48,6 +50,9 @@ type LocalsBag = {
   routeConfig?: { pagination?: unknown }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  operationOverride?: RuntimeOperationOverride
+  resolveOperationContext?: () => unknown | Promise<unknown>
   data?: unknown
 }
 
@@ -55,6 +60,8 @@ function buildContext(req: Request, res: Response): OperationContext {
   const extReq = req as ExtendedRequest
   const locals = res.locals as LocalsBag
   return {
+    operationOverride: locals.operationOverride,
+    resolveOperationContext: locals.resolveOperationContext,
     prisma: extReq.prisma,
     postgres: extReq.postgres,
     sqlite: extReq.sqlite,
@@ -62,9 +69,10 @@ function buildContext(req: Request, res: Response): OperationContext {
     body: req.body,
     guardShape: locals.guardShape,
     guardCaller: locals.guardCaller,
+    guardVariantKey: locals.guardVariantKey,
     paginationConfig: (locals.routeConfig?.pagination) as OperationContext['paginationConfig'],
   }
 }
 ${handlers}
 `
-}
+}

package/src/generators/generateUnifiedScalarUI.ts

@@ -215,4 +215,4 @@ const MODEL_CONTEXT: DocsModelContext = {
 
 ${docsExport}
 `
-}
+}