prisma-generator-express 1.62.4 → 1.63.1

package/src/copy/routeConfig.ts

@@ -1,3 +1,10 @@
+import { GUARD_SHAPE_CONFIG_KEYS } from './guardHelpers'
+import { isPlainObject } from './misc'
+import {
+  resolveGuardVariantKey,
+  type GuardVariantResolution,
+} from './guardVariantRouting'
+
 export interface QueryBuilderConfig {
   enabled?: boolean
   port?: number
@@ -87,23 +94,43 @@ export type ProgressiveVariantConfig =
   | ManualProgressiveVariantConfig
   | AutoIncludeProgressiveVariantConfig
 
-export interface BaseOperationConfig<HookHandler, TShape = Record<string, unknown>> {
-  before?: HookHandler[]
-  after?: HookHandler[]
-  shape?: TShape
+export type VariantEntry<TShape, TBefore, TAfter> = {
+  shape: TShape
+  before?: TBefore[]
+  after?: TAfter[]
+}
+
+type OperationShapeConfig<TShape, TBefore, TAfter> =
+  | {
+      shape?: TShape
+      variants?: never
+    }
+  | {
+      shape?: never
+      variants: Record<string, VariantEntry<TShape, TBefore, TAfter>>
+    }
+
+export type BaseOperationConfig<
+  TBefore,
+  TShape = Record<string, unknown>,
+  TAfter = TBefore,
+> = OperationShapeConfig<TShape, TBefore, TAfter> & {
+  before?: TBefore[]
+  after?: TAfter[]
   pagination?: Partial<PaginationConfig>
 }
 
-export interface BaseUpdateEachConfig<HookHandler> {
-  before?: HookHandler[]
-  after?: HookHandler[]
+export interface BaseUpdateEachConfig<TBefore, TAfter = TBefore> {
+  before?: TBefore[]
+  after?: TAfter[]
 }
 
 export interface BaseRouteConfig<
-  HookHandler,
+  TBefore,
   RequestType,
   TShape = Record<string, unknown>,
   TCtx = unknown,
+  TAfter = TBefore,
 > {
   enableAll?: boolean
   addModelPrefix?: boolean
@@ -125,30 +152,196 @@ export interface BaseRouteConfig<
   resolveContext?: (request: RequestType) => TCtx | Promise<TCtx>
   queryBuilder?: QueryBuilderConfig | false
   pagination?: PaginationConfig
-  findUnique?: BaseOperationConfig<HookHandler, TShape> | false
-  findUniqueOrThrow?: BaseOperationConfig<HookHandler, TShape> | false
-  findFirst?: BaseOperationConfig<HookHandler, TShape> | false
-  findFirstOrThrow?: BaseOperationConfig<HookHandler, TShape> | false
-  findMany?: BaseOperationConfig<HookHandler, TShape> | false
-  findManyPaginated?: BaseOperationConfig<HookHandler, TShape> | false
-  create?: BaseOperationConfig<HookHandler, TShape> | false
-  createMany?: BaseOperationConfig<HookHandler, TShape> | false
-  createManyAndReturn?: BaseOperationConfig<HookHandler, TShape> | false
-  update?: BaseOperationConfig<HookHandler, TShape> | false
-  updateMany?: BaseOperationConfig<HookHandler, TShape> | false
-  updateManyAndReturn?: BaseOperationConfig<HookHandler, TShape> | false
-  upsert?: BaseOperationConfig<HookHandler, TShape> | false
-  delete?: BaseOperationConfig<HookHandler, TShape> | false
-  deleteMany?: BaseOperationConfig<HookHandler, TShape> | false
-  updateEach?: BaseUpdateEachConfig<HookHandler>
-  aggregate?: BaseOperationConfig<HookHandler, TShape> | false
-  count?: BaseOperationConfig<HookHandler, TShape> | false
-  groupBy?: BaseOperationConfig<HookHandler, TShape> | false
+  findUnique?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findUniqueOrThrow?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findFirst?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findFirstOrThrow?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findManyPaginated?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  create?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  createMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  createManyAndReturn?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  update?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateManyAndReturn?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  upsert?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  delete?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  deleteMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateEach?: BaseUpdateEachConfig<TBefore, TAfter>
+  aggregate?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  count?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  groupBy?: BaseOperationConfig<TBefore, TShape, TAfter> | false
 }
 
 export type OperationConfig = BaseOperationConfig<unknown>
 export type RouteConfig = BaseRouteConfig<unknown, unknown>
 
+export type NormalizedGuardRouting =
+  | { kind: 'none' }
+  | { kind: 'single' }
+  | { kind: 'named'; keys: readonly string[] }
+
+export type NormalizedVariantHooks<TBefore, TAfter> = Readonly<
+  Record<
+    string,
+    {
+      before: readonly TBefore[]
+      after: readonly TAfter[]
+    }
+  >
+>
+
+export interface NormalizedOperationConfig<TBefore, TAfter> {
+  guardShape?: Record<string, unknown>
+  guardRouting: NormalizedGuardRouting
+  operationBefore: readonly TBefore[]
+  operationAfter: readonly TAfter[]
+  variantHooks: NormalizedVariantHooks<TBefore, TAfter>
+  pagination?: Readonly<Partial<PaginationConfig>>
+}
+
+type OperationConfigInput<TBefore, TAfter> = {
+  before?: TBefore[]
+  after?: TAfter[]
+  shape?: unknown
+  variants?: Record<
+    string,
+    {
+      shape?: unknown
+      before?: TBefore[]
+      after?: TAfter[]
+    }
+  >
+  pagination?: Partial<PaginationConfig>
+}
+
+function classifyGuardRouting(shape: unknown): NormalizedGuardRouting {
+  if (shape === undefined) return { kind: 'none' }
+  if (typeof shape === 'function') return { kind: 'single' }
+  if (!isPlainObject(shape)) return { kind: 'single' }
+
+  const keys = Object.keys(shape)
+  const isSingle =
+    keys.length === 0 ||
+    keys.every((key) => GUARD_SHAPE_CONFIG_KEYS.has(key))
+
+  return isSingle ? { kind: 'single' } : { kind: 'named', keys }
+}
+
+export function validateOperationConfig(
+  config: { shape?: unknown; variants?: unknown } | undefined,
+  location: string,
+): void {
+  if (!config) return
+
+  const hasShape = config.shape !== undefined
+  const hasVariants = config.variants !== undefined
+
+  if (hasShape && hasVariants) {
+    throw new Error(location + ': shape and variants cannot both be defined')
+  }
+
+  if (!hasVariants) return
+
+  const variants = config.variants
+  if (!isPlainObject(variants)) {
+    throw new Error(location + ': variants must be a non-array object')
+  }
+
+  const entries = Object.entries(variants)
+  if (entries.length === 0) {
+    throw new Error(location + ': variants must contain at least one entry')
+  }
+
+  for (const [key, rawEntry] of entries) {
+    if (GUARD_SHAPE_CONFIG_KEYS.has(key)) {
+      throw new Error(
+        location + ': variant name "' + key +
+        '" collides with a reserved guard shape key',
+      )
+    }
+
+    if (!isPlainObject(rawEntry)) {
+      throw new Error(
+        location + ': variant "' + key + '" must be an object with a shape',
+      )
+    }
+
+    if (rawEntry.shape === undefined) {
+      throw new Error(
+        location + ': variant "' + key + '" is missing "shape"',
+      )
+    }
+  }
+}
+
+export function validateUpdateEachConfig(
+  config: { variants?: unknown } | undefined,
+  location: string,
+): void {
+  if (config?.variants !== undefined) {
+    throw new Error(location + ': updateEach does not support variants')
+  }
+}
+
+export function normalizeOperation<TBefore, TAfter>(
+  config: OperationConfigInput<TBefore, TAfter> | undefined,
+): NormalizedOperationConfig<TBefore, TAfter> {
+  const operationBefore = config?.before ?? []
+  const operationAfter = config?.after ?? []
+
+  if (config?.variants !== undefined) {
+    const entries = Object.entries(config.variants)
+
+    return {
+      guardShape: Object.fromEntries(
+        entries.map(([key, entry]) => [key, entry.shape]),
+      ),
+      guardRouting: {
+        kind: 'named',
+        keys: entries.map(([key]) => key),
+      },
+      operationBefore,
+      operationAfter,
+      variantHooks: Object.fromEntries(
+        entries.map(([key, entry]) => [
+          key,
+          {
+            before: entry.before ?? [],
+            after: entry.after ?? [],
+          },
+        ]),
+      ),
+      pagination: config.pagination,
+    }
+  }
+
+  return {
+    guardShape: config?.shape as Record<string, unknown> | undefined,
+    guardRouting: classifyGuardRouting(config?.shape),
+    operationBefore,
+    operationAfter,
+    variantHooks: {},
+    pagination: config?.pagination,
+  }
+}
+
+export function resolveOperationVariantKey(
+  routing: NormalizedGuardRouting,
+  caller: string | undefined,
+): GuardVariantResolution {
+  if (routing.kind === 'none' || routing.kind === 'single') {
+    return resolveGuardVariantKey({ kind: 'single' })
+  }
+
+  return resolveGuardVariantKey({
+    kind: 'named',
+    keys: routing.keys,
+    caller,
+    reservedKeys: GUARD_SHAPE_CONFIG_KEYS,
+  })
+}
+
 export function validateCountSourceWhere(
   cs: PaginationCountSource | undefined,
   location: string,

package/src/generators/generateRouteConfigType.ts

@@ -74,25 +74,55 @@ export function generateRouteConfigType(
 
   const shapeOps = Array.from(new Set(ROUTER_OPERATIONS))
   const opShapeImports = shapeOps
-    .map((op) => `${m}${capitalize(op)}ShapeInput`)
+    .flatMap((op) => {
+      const prefix = `${m}${capitalize(op)}Shape`
+      return [prefix, `${prefix}Input`]
+    })
     .join(',\n  ')
 
+  const shapeOrFnAliases = shapeOps
+    .map((op) => {
+      const prefix = `${m}${capitalize(op)}Shape`
+      return (
+        `type ${prefix}OrFn<TCtx = unknown> =\n` +
+        `  | ${prefix}\n` +
+        `  | ((ctx: TCtx) => ${prefix})`
+      )
+    })
+    .join('\n\n')
+
   const overrides = ROUTER_OPERATIONS.map((routerOp) => {
     const c = capitalize(routerOp)
     const isRead = READ_OPERATION_NAMES.has(routerOp)
-    const lines = [
+    const commonLines = [
       `    before?: ${beforeRef}[]`,
       `    after?: ${afterRef}[]`,
-      `    shape?: ${m}${c}ShapeInput<TCtx>`,
       `    pagination?: Partial<PaginationConfig>`,
     ]
+
     if (isRead && supportsProgressive) {
-      lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
-      lines.push(
+      commonLines.push(
+        `    progressive?: Record<string, ProgressiveVariantConfig>`,
+      )
+      commonLines.push(
         `    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`,
       )
     }
-    return `  ${routerOp}?: {\n${lines.join('\n')}\n  } | false`
+
+    const commonConfig = `{\n${commonLines.join('\n')}\n  }`
+    const variantsConfig =
+      `Record<string, {\n` +
+      `      shape: ${m}${c}ShapeOrFn<TCtx>\n` +
+      `      before?: ${beforeRef}[]\n` +
+      `      after?: ${afterRef}[]\n` +
+      `    }>`
+
+    return (
+      `  ${routerOp}?: (${commonConfig} & (\n` +
+      `    | { shape?: ${m}${c}ShapeInput<TCtx>; variants?: never }\n` +
+      `    | { shape?: never; variants: ${variantsConfig} }\n` +
+      `  )) | false`
+    )
   }).join('\n')
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
@@ -100,6 +130,7 @@ export function generateRouteConfigType(
   return (
     progressiveTypeImport +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
+    `${shapeOrFnAliases}\n\n` +
     `export type ${m}RouteConfig${generics} = Omit<\n` +
     `  ${baseConfig},\n` +
     `  | ${omitKeys}\n` +

package/src/generators/generateRouter.ts

@@ -57,15 +57,37 @@ function emitReadOp(
   const postReadBlock = meta.supportsPostRead
     ? `    if (postReadsEnabled) {
       const postPath = ${meta.name === 'findMany' ? "basePath ? `${basePath}/read` : '/read'" : `path`}
-      router.post(postPath, parseBodyAsQuery, setShape(opConfig, '${opKind}'), ...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, '${opKind}'), ...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}
   }`
 }
@@ -81,10 +103,19 @@ function emitWriteOp(
   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, '${opKind}'), ...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},
+    )
   }`
 }
 
@@ -146,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,
@@ -173,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
@@ -190,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
@@ -215,6 +275,91 @@ 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: unknown = handler(req, res, next)
+      if (
+        typeof result === 'object' &&
+        result !== null &&
+        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(
@@ -226,6 +371,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
@@ -312,7 +463,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     next()
   }
 
-  const setShape = (opConfig: OperationConfigLike, opKind: OpKind): RequestHandler => {
+  const setShape = (opConfig: NormalizedOp, opKind: OpKind): RequestHandler => {
     return async (req, res, next) => {
       try {
         const locals = readLocals(res)
@@ -320,17 +471,32 @@ 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 {
             await applyDroppedGuard(
-              opConfig.shape,
-              caller,
+              opConfig.guardShape,
+              resolvedKey,
               buildResolveContext(req),
               opKind,
               {
@@ -352,6 +518,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
             )
           }
         }
+
         next()
       } catch (err) {
         next(mapError(err))
@@ -360,7 +527,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   }
 
   const maybeProgressiveSSE = (
-    opConfig: OperationConfigLike,
+    opConfig: NormalizedOp,
     coreFn: (ctx: OperationContext) => Promise<unknown>,
     baseOp: string,
   ): RequestHandler => {
@@ -370,8 +537,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) {
@@ -499,19 +667,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, 'noop'),
-      ...before,
+      ...opConfig.operationBefore,
       async (req: Request, res: Response, next: NextFunction) => {
         try {
           if (!Array.isArray(req.body)) {
@@ -524,7 +693,7 @@ ${writeOpBlocks}
           next(mapError(err))
         }
       },
-      ...after,
+      ...opConfig.operationAfter,
       respond,
     )
   }