prisma-generator-express 1.62.3 → 1.63.0

package/src/generators/generateRouter.ts

@@ -11,6 +11,40 @@ function pathExpr(basePath: string, suffix: string): string {
   return `\`\${basePath}${suffix}\``
 }
 
+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'
+  }
+}
+
 function emitReadOp(
   meta: (typeof OPERATION_METADATA)[number],
   modelName: string,
@@ -18,19 +52,42 @@ function emitReadOp(
   const c = meta.name.charAt(0).toUpperCase() + meta.name.slice(1)
   const handlerName = `${modelName}${c}`
   const pathValue = pathExpr('basePath', meta.pathSuffix)
+  const opKind = opKindFor(meta.name)
 
   const postReadBlock = meta.supportsPostRead
     ? `    if (postReadsEnabled) {
       const postPath = ${meta.name === 'findMany' ? "basePath ? `${basePath}/read` : '/read'" : `path`}
-      router.post(postPath, parseBodyAsQuery, setShape(opConfig, 'read'), ...before, ${handlerName} as RequestHandler, ...after, respond)
+      router.post(
+        postPath,
+        parseBodyAsQuery,
+        setShape(opConfig, '${opKind}'),
+        ...opConfig.operationBefore,
+        requireVariantKey(),
+        variantBeforeDispatcher(opConfig),
+        ${handlerName} as RequestHandler,
+        variantAfterDispatcher(opConfig),
+        ...opConfig.operationAfter,
+        respond,
+      )
     }`
     : ''
 
   return `  if (isEnabled(config.${meta.configKey})) {
-    const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
+    const opConfig = opFor('${meta.configKey}')
     const path = ${pathValue}
-    router.get(path, parseQuery, setShape(opConfig, 'read'), ...before, maybeProgressiveSSE(opConfig, core.${meta.coreName}, '${meta.name}'), ${handlerName} as RequestHandler, ...after, respond)
+    router.get(
+      path,
+      parseQuery,
+      setShape(opConfig, '${opKind}'),
+      ...opConfig.operationBefore,
+      requireVariantKey(),
+      variantBeforeDispatcher(opConfig),
+      maybeProgressiveSSE(opConfig, core.${meta.coreName}, '${meta.name}'),
+      ${handlerName} as RequestHandler,
+      variantAfterDispatcher(opConfig),
+      ...opConfig.operationAfter,
+      respond,
+    )
 ${postReadBlock}
   }`
 }
@@ -43,12 +100,22 @@ function emitWriteOp(
   const handlerName = `${modelName}${c}`
   const pathValue = pathExpr('basePath', meta.pathSuffix)
   const respondFn = meta.successStatus === 201 ? 'respondCreated' : 'respond'
+  const opKind = opKindFor(meta.name)
 
   return `  if (isEnabled(config.${meta.configKey})) {
-    const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
+    const opConfig = opFor('${meta.configKey}')
     const path = ${pathValue}
-    router.${meta.method}(path, setShape(opConfig, 'write'), ...before, ${handlerName} as RequestHandler, ...after, ${respondFn})
+    router.${meta.method}(
+      path,
+      setShape(opConfig, '${opKind}'),
+      ...opConfig.operationBefore,
+      requireVariantKey(),
+      variantBeforeDispatcher(opConfig),
+      ${handlerName} as RequestHandler,
+      variantAfterDispatcher(opConfig),
+      ...opConfig.operationAfter,
+      ${respondFn},
+    )
   }`
 }
 
@@ -110,10 +177,19 @@ import type {
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv, isPlainObject } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
-import { validateCountSourceWhere } from '../routeConfig${ext}'
+import {
+  normalizeOperation,
+  resolveOperationVariantKey,
+  validateCountSourceWhere,
+  validateOperationConfig,
+  validateUpdateEachConfig,
+} from '../routeConfig${ext}'
+import type { NormalizedOperationConfig } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
 import { transformResult } from '../operationRuntime${ext}'
 import { HttpError, mapError } from '../errorMapper${ext}'
+import { formatGuardVariantResolutionError } from '../guardVariantError${ext}'
+import type { GuardVariantResolution } from '../guardVariantRouting${ext}'
 import { mergePaginationConfig } from '../pagination${ext}'
 import {
   acceptsEventStream,
@@ -124,10 +200,8 @@ import {
 } from '../sse${ext}'
 import { relationModels } from '../relationModels${ext}'
 import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
-import {
-  resolveDroppedGuardProjection,
-  applyProjectionToTarget,
-} from '../projectionDefaults${ext}'
+import { applyDroppedGuard } from '../projectionDefaults${ext}'
+import type { OpKind } from '../projectionDefaults${ext}'
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
@@ -139,12 +213,25 @@ const DROP_GUARD = ${dropGuard} || _env.E2E === 'true'
 type OperationConfigLike = {
   before?: RequestHandler[]
   after?: RequestHandler[]
-  shape?: Record<string, unknown>
+  shape?: unknown
+  variants?: Record<
+    string,
+    {
+      shape?: unknown
+      before?: RequestHandler[]
+      after?: RequestHandler[]
+    }
+  >
   pagination?: Partial<PaginationConfig>
   progressive?: Record<string, ProgressiveVariantConfig>
   progressiveStages?: Record<string, ProgressiveStage<unknown>>
 }
 
+type NormalizedOp = NormalizedOperationConfig<RequestHandler, RequestHandler> & {
+  progressive?: Record<string, ProgressiveVariantConfig>
+  progressiveStages?: Record<string, ProgressiveStage<unknown>>
+}
+
 type ExtendedRequest = Request & {
   prisma?: unknown
   postgres?: unknown
@@ -156,13 +243,20 @@ type LocalsBag = {
   routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  guardVariantFailure?: Extract<GuardVariantResolution, { ok: false }>
   data?: unknown
 }
 
-const defaultOpConfig: OperationConfigLike = Object.freeze({
-  before: Object.freeze([]) as unknown as RequestHandler[],
-  after: Object.freeze([]) as unknown as RequestHandler[],
-})
+function normalizeExpressOperation(
+  config: OperationConfigLike | undefined,
+): NormalizedOp {
+  return {
+    ...normalizeOperation<RequestHandler, RequestHandler>(config),
+    progressive: config?.progressive,
+    progressiveStages: config?.progressiveStages,
+  }
+}
 
 function isQueryBuilderEnabled(config: { queryBuilder?: QueryBuilderConfig | false }): boolean {
   if (config.queryBuilder === false) return false
@@ -181,6 +275,87 @@ function readLocals(res: Response): LocalsBag {
   return res.locals as LocalsBag
 }
 
+function runHandlerSequence(
+  handlers: readonly RequestHandler[],
+  req: Request,
+  res: Response,
+  done: (error?: unknown) => void,
+): void {
+  let index = 0
+
+  const dispatch = (error?: unknown): void => {
+    if (error !== undefined) {
+      done(error)
+      return
+    }
+
+    if (res.writableEnded || res.destroyed) return
+
+    const handler = handlers[index++]
+    if (!handler) {
+      done()
+      return
+    }
+
+    let settled = false
+    const next = (nextError?: unknown): void => {
+      if (settled) return
+      settled = true
+      dispatch(nextError)
+    }
+
+    try {
+      const result = handler(req, res, next)
+      if (result && typeof (result as Promise<unknown>).then === 'function') {
+        void (result as Promise<unknown>).catch((promiseError) => {
+          if (settled) return
+          settled = true
+          dispatch(promiseError)
+        })
+      }
+    } catch (handlerError) {
+      if (settled) return
+      settled = true
+      dispatch(handlerError)
+    }
+  }
+
+  dispatch()
+}
+
+function variantBeforeDispatcher(opConfig: NormalizedOp): RequestHandler {
+  return (req, res, next) => {
+    const key = readLocals(res).guardVariantKey
+    const hooks =
+      key !== undefined
+        ? (opConfig.variantHooks[key]?.before ?? [])
+        : []
+    runHandlerSequence(hooks, req, res, next)
+  }
+}
+
+function variantAfterDispatcher(opConfig: NormalizedOp): RequestHandler {
+  return (req, res, next) => {
+    const key = readLocals(res).guardVariantKey
+    const hooks =
+      key !== undefined
+        ? (opConfig.variantHooks[key]?.after ?? [])
+        : []
+    runHandlerSequence(hooks, req, res, next)
+  }
+}
+
+function requireVariantKey(): RequestHandler {
+  return (_req, res, next) => {
+    const failure = readLocals(res).guardVariantFailure
+    if (!failure) {
+      next()
+      return
+    }
+    next(new HttpError(400, formatGuardVariantResolutionError(failure)))
+  }
+}
+
 export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${modelName}RouteConfig<TCtx, TPrisma> = {}) {
   validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
   validateCountSourceWhere(
@@ -192,6 +367,12 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
 
   const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
 
+  const opFor = (key: string): NormalizedOp => {
+    const raw = (config as unknown as Record<string, unknown>)[key] as OperationConfigLike | undefined
+    validateOperationConfig(raw, '${modelName}.' + key)
+    return normalizeExpressOperation(raw)
+  }
+
   const customPrefix = normalizePrefix(config.customUrlPrefix || '')
   const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
   const basePath = customPrefix + modelPrefix
@@ -278,7 +459,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     next()
   }
 
-  const setShape = (opConfig: OperationConfigLike, kind: 'read' | 'write'): RequestHandler => {
+  const setShape = (opConfig: NormalizedOp, opKind: OpKind): RequestHandler => {
     return async (req, res, next) => {
       try {
         const locals = readLocals(res)
@@ -286,35 +467,54 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         if (merged) {
           locals.routeConfig = { pagination: merged }
         }
+
         const headerName = config.guard?.variantHeader || 'x-api-variant'
         const headerValue = req.get(headerName)
         const caller = config.guard?.resolveVariant?.(req) ?? headerValue ?? undefined
-        if (caller) locals.guardCaller = caller
-        if (opConfig.shape) {
+        if (typeof caller === 'string') locals.guardCaller = caller
+
+        const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
+        if (!resolution.ok) {
+          locals.guardVariantFailure = resolution
+          next()
+          return
+        }
+
+        const resolvedKey =
+          opConfig.guardRouting.kind === 'named'
+            ? resolution.key
+            : undefined
+        if (resolvedKey !== undefined) locals.guardVariantKey = resolvedKey
+
+        if (opConfig.guardShape) {
           if (!DROP_GUARD) {
-            locals.guardShape = opConfig.shape
+            locals.guardShape = opConfig.guardShape
           } else {
-            const projection = await resolveDroppedGuardProjection(
-              opConfig.shape,
-              caller,
+            await applyDroppedGuard(
+              opConfig.guardShape,
+              resolvedKey,
               buildResolveContext(req),
-            )
-            if (projection) {
-              if (kind === 'read') {
+              opKind,
+              {
+                readQuery: locals.parsedQuery,
+                writeBody: isPlainObject(req.body)
+                  ? (req.body as Record<string, unknown>)
+                  : undefined,
+              },
+              () => {
                 if (!locals.parsedQuery) locals.parsedQuery = {}
-                applyProjectionToTarget(locals.parsedQuery, projection)
-              } else {
+                return locals.parsedQuery
+              },
+              () => {
                 if (!isPlainObject(req.body)) {
                   req.body = {}
                 }
-                applyProjectionToTarget(
-                  req.body as Record<string, unknown>,
-                  projection,
-                )
-              }
-            }
+                return req.body as Record<string, unknown>
+              },
+            )
           }
         }
+
         next()
       } catch (err) {
         next(mapError(err))
@@ -323,7 +523,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   }
 
   const maybeProgressiveSSE = (
-    opConfig: OperationConfigLike,
+    opConfig: NormalizedOp,
     coreFn: (ctx: OperationContext) => Promise<unknown>,
     baseOp: string,
   ): RequestHandler => {
@@ -333,8 +533,9 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
       if (!acceptsEventStream(req.headers.accept)) return next()
 
       const locals = readLocals(res)
-      const variant = locals.guardCaller
-      const progressiveConfig = variant ? opConfig.progressive?.[variant] : undefined
+      const variant = locals.guardVariantKey ?? locals.guardCaller
+      const progressiveConfig =
+        variant !== undefined ? opConfig.progressive?.[variant] : undefined
 
       try {
         if (!progressiveConfig || progressiveConfig.enabled === false) {
@@ -462,19 +663,20 @@ ${readOpBlocks}
 ${writeOpBlocks}
 
   if (config.updateEach) {
-    const opConfig: OperationConfigLike = (config.updateEach as OperationConfigLike | undefined) ?? defaultOpConfig
-    if ((!opConfig.before || opConfig.before.length === 0) && _env.NODE_ENV !== 'production') {
+    const rawUpdateEach = config.updateEach as unknown as OperationConfigLike
+    validateUpdateEachConfig(rawUpdateEach, '${modelName}.updateEach')
+    const opConfig = normalizeExpressOperation(rawUpdateEach)
+    if (opConfig.operationBefore.length === 0 && _env.NODE_ENV !== 'production') {
       console.warn(
         '[${modelName}Router] updateEach is enabled without a before hook. ' +
         'This endpoint bypasses guard shapes and should be protected by authentication middleware.',
       )
     }
-    const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/each\` : '/each'
     router.post(
       path,
-      setShape(opConfig, 'write'),
-      ...before,
+      setShape(opConfig, 'noop'),
+      ...opConfig.operationBefore,
       async (req: Request, res: Response, next: NextFunction) => {
         try {
           if (!Array.isArray(req.body)) {
@@ -487,7 +689,7 @@ ${writeOpBlocks}
           next(mapError(err))
         }
       },
-      ...after,
+      ...opConfig.operationAfter,
       respond,
     )
   }

package/src/generators/generateRouterFastify.ts

@@ -63,7 +63,7 @@ function emitReadOp(
     : ''
 
   return `    if (isEnabled(config.${meta.configKey})) {
-      const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+      const opConfig = opFor('${meta.configKey}')
       const path = ${pathValue}
       instance.get(path, handleRead(opConfig, ${handlerName}, parseQueryHook, '${opKind}'))
 ${postReadLine}
@@ -80,7 +80,7 @@ function emitWriteOp(
   const opKind = opKindFor(meta.name)
 
   return `    if (isEnabled(config.${meta.configKey})) {
-      const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+      const opConfig = opFor('${meta.configKey}')
       const path = ${pathValue}
       instance.${meta.method}(path, handleWrite(opConfig, ${handlerName}, '${opKind}'))
     }`
@@ -133,10 +133,19 @@ import type {
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv, isPlainObject } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
-import { validateCountSourceWhere } from '../routeConfig${ext}'
+import {
+  normalizeOperation,
+  resolveOperationVariantKey,
+  validateCountSourceWhere,
+  validateOperationConfig,
+  validateUpdateEachConfig,
+} from '../routeConfig${ext}'
+import type { NormalizedOperationConfig } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
 import { transformResult } from '../operationRuntime${ext}'
 import { HttpError, mapError } from '../errorMapper${ext}'
+import { formatGuardVariantResolutionError } from '../guardVariantError${ext}'
+import type { GuardVariantResolution } from '../guardVariantRouting${ext}'
 import { mergePaginationConfig } from '../pagination${ext}'
 import { applyDroppedGuard } from '../projectionDefaults${ext}'
 import type { OpKind } from '../projectionDefaults${ext}'
@@ -151,10 +160,23 @@ const DROP_GUARD = ${dropGuard} || _env.E2E === 'true'
 type OperationConfigLike = {
   before?: FastifyHookHandler[]
   after?: FastifyHookHandler[]
-  shape?: Record<string, unknown>
+  shape?: unknown
+  variants?: Record<
+    string,
+    {
+      shape?: unknown
+      before?: FastifyHookHandler[]
+      after?: FastifyHookHandler[]
+    }
+  >
   pagination?: Partial<PaginationConfig>
 }
 
+type NormalizedOp = NormalizedOperationConfig<
+  FastifyHookHandler,
+  FastifyHookHandler
+>
+
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown
   postgres?: unknown
@@ -163,14 +185,17 @@ type FastifyExtended = FastifyRequest & {
   routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  guardVariantFailure?: Extract<GuardVariantResolution, { ok: false }>
   resultData?: unknown
   resultStatus?: number
 }
 
-const defaultOpConfig: OperationConfigLike = Object.freeze({
-  before: Object.freeze([]) as unknown as FastifyHookHandler[],
-  after: Object.freeze([]) as unknown as FastifyHookHandler[],
-})
+function normalizeFastifyOperation(
+  config: OperationConfigLike | undefined,
+): NormalizedOp {
+  return normalizeOperation<FastifyHookHandler, FastifyHookHandler>(config)
+}
 
 function isQueryBuilderEnabled(config: RouteConfig): boolean {
   if (config.queryBuilder === false) return false
@@ -210,7 +235,7 @@ function buildResolveContext(
 
 function makeShapeHook(
   config: ${modelName}RouteConfig,
-  opConfig: OperationConfigLike,
+  opConfig: NormalizedOp,
   opKind: OpKind,
 ): (request: FastifyRequest) => Promise<void> {
   return async (request: FastifyRequest) => {
@@ -223,15 +248,27 @@ function makeShapeHook(
     const caller = config.guard?.resolveVariant?.(request)
       ?? (Array.isArray(headerValue) ? headerValue[0] : headerValue)
       ?? undefined
-    if (caller) fx.guardCaller = caller
+    if (typeof caller === 'string') fx.guardCaller = caller
+
+    const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
+    if (!resolution.ok) {
+      fx.guardVariantFailure = resolution
+      return
+    }
+
+    const resolvedKey =
+      opConfig.guardRouting.kind === 'named'
+        ? resolution.key
+        : undefined
+    if (resolvedKey !== undefined) fx.guardVariantKey = resolvedKey
 
-    if (opConfig.shape) {
+    if (opConfig.guardShape) {
       if (!DROP_GUARD) {
-        fx.guardShape = opConfig.shape
+        fx.guardShape = opConfig.guardShape
       } else {
         await applyDroppedGuard(
-          opConfig.shape,
-          caller,
+          opConfig.guardShape,
+          resolvedKey,
           buildResolveContext(config, request),
           opKind,
           {
@@ -257,7 +294,7 @@ function makeShapeHook(
 }
 
 async function runHooks(
-  hooks: FastifyHookHandler[],
+  hooks: readonly FastifyHookHandler[],
   request: FastifyRequest,
   reply: FastifyReply,
 ): Promise<boolean> {
@@ -298,6 +335,12 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
   await fastify.register(async (instance) => {
     const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
 
+    const opFor = (key: string): NormalizedOp => {
+      const raw = (config as unknown as Record<string, unknown>)[key] as OperationConfigLike | undefined
+      validateOperationConfig(raw, '${modelName}.' + key)
+      return normalizeFastifyOperation(raw)
+    }
+
     const customPrefix = normalizePrefix(config.customUrlPrefix || '')
     const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
     const basePath = customPrefix + modelPrefix
@@ -375,7 +418,7 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
     }
 
     const handleRead = (
-      opConfig: OperationConfigLike,
+      opConfig: NormalizedOp,
       handlerFn: (req: FastifyRequest, reply: FastifyReply) => Promise<void>,
       parseFn: (req: FastifyRequest) => void,
       opKind: OpKind,
@@ -383,10 +426,24 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
       try {
         parseFn(request)
         await makeShapeHook(config, opConfig, opKind)(request)
-        const { before = [], after = [] } = opConfig
-        if (await runHooks(before, request, reply)) return
+        if (await runHooks(opConfig.operationBefore, request, reply)) return
+
+        const fx = request as FastifyExtended
+        if (fx.guardVariantFailure) {
+          throw new HttpError(
+            400,
+            formatGuardVariantResolutionError(fx.guardVariantFailure),
+          )
+        }
+
+        const key = fx.guardVariantKey
+        const variantHooks =
+          key !== undefined ? opConfig.variantHooks[key] : undefined
+
+        if (await runHooks(variantHooks?.before ?? [], request, reply)) return
         await handlerFn(request, reply)
-        if (await runHooks(after, request, reply)) return
+        if (await runHooks(variantHooks?.after ?? [], request, reply)) return
+        if (await runHooks(opConfig.operationAfter, request, reply)) return
         sendResult(request, reply)
       } catch (error: unknown) {
         sendError(reply, error)
@@ -394,16 +451,30 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
     }
 
     const handleWrite = (
-      opConfig: OperationConfigLike,
+      opConfig: NormalizedOp,
       handlerFn: (req: FastifyRequest, reply: FastifyReply) => Promise<void>,
       opKind: OpKind,
     ) => async (request: FastifyRequest, reply: FastifyReply) => {
       try {
         await makeShapeHook(config, opConfig, opKind)(request)
-        const { before = [], after = [] } = opConfig
-        if (await runHooks(before, request, reply)) return
+        if (await runHooks(opConfig.operationBefore, request, reply)) return
+
+        const fx = request as FastifyExtended
+        if (fx.guardVariantFailure) {
+          throw new HttpError(
+            400,
+            formatGuardVariantResolutionError(fx.guardVariantFailure),
+          )
+        }
+
+        const key = fx.guardVariantKey
+        const variantHooks =
+          key !== undefined ? opConfig.variantHooks[key] : undefined
+
+        if (await runHooks(variantHooks?.before ?? [], request, reply)) return
         await handlerFn(request, reply)
-        if (await runHooks(after, request, reply)) return
+        if (await runHooks(variantHooks?.after ?? [], request, reply)) return
+        if (await runHooks(opConfig.operationAfter, request, reply)) return
         sendResult(request, reply)
       } catch (error: unknown) {
         sendError(reply, error)
@@ -415,8 +486,10 @@ ${readOpBlocks}
 ${writeOpBlocks}
 
     if (config.updateEach) {
-      const opConfig: OperationConfigLike = (config.updateEach as OperationConfigLike | undefined) ?? defaultOpConfig
-      if ((!opConfig.before || opConfig.before.length === 0) && _env.NODE_ENV !== 'production') {
+      const rawUpdateEach = config.updateEach as unknown as OperationConfigLike
+      validateUpdateEachConfig(rawUpdateEach, '${modelName}.updateEach')
+      const opConfig = normalizeFastifyOperation(rawUpdateEach)
+      if (opConfig.operationBefore.length === 0 && _env.NODE_ENV !== 'production') {
         console.warn(
           '[${modelName}Router] updateEach is enabled without a before hook. ' +
           'This endpoint bypasses guard shapes and should be protected by authentication middleware.',
@@ -429,10 +502,9 @@ ${writeOpBlocks}
             throw new HttpError(400, 'updateEach body must be an array of { where, data } items')
           }
           await makeShapeHook(config, opConfig, 'noop')(request)
-          const { before = [], after = [] } = opConfig
-          if (await runHooks(before, request, reply)) return
+          if (await runHooks(opConfig.operationBefore, request, reply)) return
           await ${modelName}UpdateEach(request, reply)
-          if (await runHooks(after, request, reply)) return
+          if (await runHooks(opConfig.operationAfter, request, reply)) return
           sendResult(request, reply)
         } catch (error: unknown) {
           sendError(reply, error)