prisma-generator-express 1.41.0 → 1.43.0

package/src/generators/generateRelationMeta.ts

@@ -0,0 +1,154 @@
+import { DMMF } from '@prisma/generator-helper'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+
+type RelationDirection = 'parentOwnsFk' | 'childOwnsFk' | 'implicitM2M'
+
+type RelationFieldMeta = {
+  name: string
+  type: string
+  isList: boolean
+  isRequired: boolean
+  direction: RelationDirection
+  parentLinkFields: string[]
+  childLinkFields: string[]
+}
+
+type ModelMeta = {
+  name: string
+  delegateKey: string
+  scalarFields: string[]
+  idFields: string[]
+  relations: Record<string, RelationFieldMeta>
+}
+
+function findOppositeField(
+  models: ReadonlyArray<DMMF.Model>,
+  targetModelName: string,
+  relationName: string | undefined,
+  selfModelName: string,
+): DMMF.Field | null {
+  if (!relationName) return null
+  const target = models.find((m) => m.name === targetModelName)
+  if (!target) return null
+  return target.fields.find(
+    (f) => f.kind === 'object' && f.relationName === relationName && f.type === selfModelName,
+  ) || null
+}
+
+function computeRelation(
+  field: DMMF.Field,
+  selfModelName: string,
+  models: ReadonlyArray<DMMF.Model>,
+): RelationFieldMeta {
+  const selfFrom = (field.relationFromFields ?? []) as string[]
+  const selfTo = (field.relationToFields ?? []) as string[]
+
+  if (selfFrom.length > 0) {
+    return {
+      name: field.name,
+      type: field.type,
+      isList: field.isList,
+      isRequired: field.isRequired,
+      direction: 'parentOwnsFk',
+      parentLinkFields: selfFrom,
+      childLinkFields: selfTo,
+    }
+  }
+
+  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName)
+  if (opposite) {
+    const oppFrom = (opposite.relationFromFields ?? []) as string[]
+    const oppTo = (opposite.relationToFields ?? []) as string[]
+    if (oppFrom.length > 0) {
+      return {
+        name: field.name,
+        type: field.type,
+        isList: field.isList,
+        isRequired: field.isRequired,
+        direction: 'childOwnsFk',
+        parentLinkFields: oppTo,
+        childLinkFields: oppFrom,
+      }
+    }
+  }
+
+  return {
+    name: field.name,
+    type: field.type,
+    isList: field.isList,
+    isRequired: field.isRequired,
+    direction: 'implicitM2M',
+    parentLinkFields: [],
+    childLinkFields: [],
+  }
+}
+
+function buildModelMeta(
+  model: DMMF.Model,
+  models: ReadonlyArray<DMMF.Model>,
+): ModelMeta {
+  const scalarFields: string[] = []
+  const idFields: string[] = []
+  const relations: Record<string, RelationFieldMeta> = {}
+
+  for (const field of model.fields) {
+    if (field.kind === 'object') {
+      relations[field.name] = computeRelation(field, model.name, models)
+    } else if (field.kind === 'scalar' || field.kind === 'enum') {
+      scalarFields.push(field.name)
+      if (field.isId) idFields.push(field.name)
+    }
+  }
+
+  if (model.primaryKey && Array.isArray(model.primaryKey.fields)) {
+    for (const f of model.primaryKey.fields) {
+      if (!idFields.includes(f)) idFields.push(f)
+    }
+  }
+
+  return {
+    name: model.name,
+    delegateKey: model.name.charAt(0).toLowerCase() + model.name.slice(1),
+    scalarFields,
+    idFields,
+    relations,
+  }
+}
+
+export interface GenerateRelationMetaOptions {
+  model: DMMF.Model
+  allModels: ReadonlyArray<DMMF.Model>
+  importStyle: ImportStyle
+}
+
+export function generateRelationMeta(options: GenerateRelationMetaOptions): string {
+  const ext = importExt(options.importStyle)
+  const meta = buildModelMeta(options.model, options.allModels)
+  return `import type { ModelRelationMap } from '../autoIncludePlanner${ext}'
+
+export const ${options.model.name}Relations: ModelRelationMap = ${JSON.stringify(meta, null, 2)}
+`
+}
+
+export interface GenerateRelationModelsIndexOptions {
+  modelNames: ReadonlyArray<string>
+  importStyle: ImportStyle
+}
+
+export function generateRelationModelsIndex(options: GenerateRelationModelsIndexOptions): string {
+  const ext = importExt(options.importStyle)
+  const imports = options.modelNames
+    .map((n) => `import { ${n}Relations } from './${n}/${n}Relations${ext}'`)
+    .join('\n')
+  const entries = options.modelNames
+    .map((n) => `  ${n}: ${n}Relations,`)
+    .join('\n')
+  return `import type { ModelRelationMap } from './autoIncludePlanner${ext}'
+${imports}
+
+export const relationModels: Record<string, ModelRelationMap> = {
+${entries}
+}
+`
+}

package/src/generators/generateRouteConfigType.ts

@@ -53,8 +53,12 @@ export function generateRouteConfigType(
   const m = modelName
   const supportsProgressive = target === 'express'
 
+  const progressiveTypeImport = supportsProgressive
+    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
+    : ''
+
   if (!guardShapesImport) {
-    return `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig<Record<string, any>, TCtx>\n`
+    return progressiveTypeImport + `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig<Record<string, unknown>, TCtx>\n`
   }
 
   const shapeOps = Object.values(ROUTER_OP_TO_SHAPE_OP).filter((v, i, a) => a.indexOf(v) === i)
@@ -78,15 +82,11 @@ export function generateRouteConfigType(
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
 
-  const progressiveTypeImport = supportsProgressive
-    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
-    : ''
-
   return (
     progressiveTypeImport +
-    `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}'\n\n` +
+    `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
     `export type ${m}RouteConfig<TCtx = unknown> = Omit<\n` +
-    `  RouteConfig<Record<string, any>, TCtx>,\n` +
+    `  RouteConfig<Record<string, unknown>, TCtx>,\n` +
     `  | ${omitKeys}\n` +
     `  | 'resolveContext'\n` +
     `> & {\n` +

package/src/generators/generateRouter.ts

@@ -20,6 +20,7 @@ export function generateRouterFunction({
   const modelName = model.name
   const prefix = toCamelCase(modelName)
   const modelNameLower = modelName.toLowerCase()
+  const delegateKey = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const routerFunctionName = `${prefix}Router`
 
   const fieldsMeta = model.fields.map((f) => ({
@@ -47,6 +48,7 @@ export function generateRouterFunction({
 
   return `import express from 'express'
 import type { Request, Response, NextFunction, RequestHandler } from 'express'
+import { startQueryBuilder } from '../queryBuilder${ext}'
 import {
   ${prefix}FindUnique,
   ${prefix}FindUniqueOrThrow,
@@ -79,6 +81,8 @@ import {
   runProgressiveEndpoint,
   runSingleResultSSE,
 } from '../operationRuntime${ext}'
+import { relationModels } from '../relationModels${ext}'
+import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
 
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
 const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
@@ -86,9 +90,31 @@ const _env = typeof process !== 'undefined' && process.env ? process.env : {} as
 const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
 const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
 
-const defaultOpConfig = {
-  before: [] as RequestHandler[],
-  after: [] as RequestHandler[],
+type OperationConfigLike = {
+  before?: RequestHandler[]
+  after?: RequestHandler[]
+  shape?: Record<string, unknown>
+  progressive?: Record<string, ProgressiveVariantConfig>
+  progressiveStages?: Record<string, ProgressiveStage<unknown>>
+}
+
+type ExtendedRequest = Request & {
+  prisma?: unknown
+  postgres?: unknown
+  sqlite?: unknown
+}
+
+type LocalsBag = {
+  parsedQuery?: Record<string, unknown>
+  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
+  guardShape?: Record<string, unknown>
+  guardCaller?: string
+  data?: unknown
+}
+
+const defaultOpConfig: OperationConfigLike = {
+  before: [],
+  after: [],
 }
 
 function normalizePrefix(p: string): string {
@@ -113,6 +139,10 @@ function getQueryBuilderConfig(config: RouteConfig) {
   return {}
 }
 
+function readLocals(res: Response): LocalsBag {
+  return res.locals as LocalsBag
+}
+
 export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteConfig<TCtx> = {}) {
   const router = express.Router()
   router.use(express.json())
@@ -130,25 +160,34 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   if (qbEnabled) {
     const qbConfig = getQueryBuilderConfig(config)
     if (qbConfig) {
-      try { require('../queryBuilder${ext}').startQueryBuilder(qbConfig) } catch (err) { if (_env.NODE_ENV !== 'production') console.warn('[query-builder]', err) }
+      try {
+        startQueryBuilder(qbConfig)
+      } catch (err) {
+        if (_env.NODE_ENV !== 'production') console.warn('[query-builder]', err)
+      }
     }
   }
 
-  const buildContext = (req: Request, res: Response): OperationContext => ({
-    prisma: (req as any).prisma,
-    postgres: (req as any).postgres,
-    sqlite: (req as any).sqlite,
-    parsedQuery: res.locals.parsedQuery,
-    body: req.body,
-    guardShape: res.locals.guardShape,
-    guardCaller: res.locals.guardCaller,
-    paginationConfig: res.locals.routeConfig?.pagination,
-  })
+  const buildContext = (req: Request, res: Response): OperationContext => {
+    const extReq = req as ExtendedRequest
+    const locals = readLocals(res)
+    return {
+      prisma: extReq.prisma,
+      postgres: extReq.postgres,
+      sqlite: extReq.sqlite,
+      parsedQuery: locals.parsedQuery,
+      body: req.body,
+      guardShape: locals.guardShape,
+      guardCaller: locals.guardCaller,
+      paginationConfig: locals.routeConfig?.pagination,
+    }
+  }
 
   const parseQuery: RequestHandler = (req, res, next) => {
     const rawQuery = req.query
     if (rawQuery && Object.keys(rawQuery).length > 0) {
-      res.locals.parsedQuery = parseQueryParams(rawQuery as Record<string, unknown>)
+      const parsed = parseQueryParams(rawQuery as Record<string, unknown>) as Record<string, unknown>
+      readLocals(res).parsedQuery = parsed
     }
     next()
   }
@@ -157,29 +196,37 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
     if (!req.body || typeof req.body !== 'object' || Array.isArray(req.body)) {
       return next({ status: 400, message: 'Request body must be a JSON object' })
     }
-    res.locals.parsedQuery = sanitizeKeys(req.body)
+    readLocals(res).parsedQuery = sanitizeKeys(req.body as Record<string, unknown>)
     next()
   }
 
-  const setShape = (opConfig: any): RequestHandler => {
+  const setShape = (opConfig: OperationConfigLike): RequestHandler => {
     return (req, res, next) => {
-      res.locals.routeConfig = config
-      const caller = config.guard?.resolveVariant?.(req)
-        ?? req.get(config.guard?.variantHeader || 'x-api-variant')
-        ?? undefined
-      if (caller) res.locals.guardCaller = caller
-      if (opConfig.shape) res.locals.guardShape = opConfig.shape
+      const locals = readLocals(res)
+      if (config.pagination) {
+        locals.routeConfig = { pagination: config.pagination }
+      }
+      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) locals.guardShape = opConfig.shape
       next()
     }
   }
 
-  const maybeProgressiveSSE = (opConfig: any, coreFn: (ctx: OperationContext) => Promise<unknown>): RequestHandler => {
+  const maybeProgressiveSSE = (
+    opConfig: OperationConfigLike,
+    coreFn: (ctx: OperationContext) => Promise<unknown>,
+    baseOp: string,
+  ): RequestHandler => {
     return async (req, res, next) => {
       if (res.headersSent || res.writableEnded) return next()
       if (req.method !== 'GET') return next()
       if (!acceptsEventStream(req.headers.accept)) return next()
 
-      const variant = res.locals.guardCaller as string | undefined
+      const locals = readLocals(res)
+      const variant = locals.guardCaller
       const progressiveConfig = variant ? opConfig.progressive?.[variant] : undefined
 
       try {
@@ -192,6 +239,38 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
           return
         }
 
+        if (progressiveConfig.mode === 'autoInclude') {
+          const isSingleRecordRead =
+            baseOp === 'findUnique' || baseOp === 'findUniqueOrThrow' ||
+            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow'
+
+          if (!isSingleRecordRead) {
+            if (progressiveConfig.fallback === 'error') {
+              return next({ status: 400, message: 'autoInclude mode supports only single-record reads' })
+            }
+            await runSingleResultSSE({
+              req,
+              res,
+              coreQueryFn: () => coreFn(buildContext(req, res)),
+            })
+            return
+          }
+
+          await runAutoIncludeProgressive({
+            req,
+            res,
+            ctx: buildContext(req, res),
+            args: locals.parsedQuery ?? {},
+            baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
+            modelName: '${modelName}',
+            delegateKey: '${delegateKey}',
+            models: relationModels,
+            variantConfig: progressiveConfig,
+            coreQueryFn: () => coreFn(buildContext(req, res)),
+          })
+          return
+        }
+
         if (!Array.isArray(progressiveConfig.stages)) {
           return next({ status: 500, message: 'Progressive endpoint requires stages array' })
         }
@@ -213,12 +292,13 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
           req,
           res,
           ctx,
-          prisma: (req as any).prisma,
+          prisma: (req as ExtendedRequest).prisma,
           variant: variant as string,
           stages: progressiveConfig.stages,
           stageRegistry,
         })
       } catch (err) {
+        console.error('[progressive] dispatch error:', err)
         if (!res.headersSent) {
           return next({ status: 500, message: 'Internal server error' })
         }
@@ -227,13 +307,13 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   }
 
   const respond: RequestHandler = (_req, res) => {
-    const data = res.locals.data
+    const data = readLocals(res).data
     if (data === undefined) return res.status(500).json({ message: 'No data set by handler' })
     return res.json(transformResult(data))
   }
 
   const respondCreated: RequestHandler = (_req, res) => {
-    const data = res.locals.data
+    const data = readLocals(res).data
     if (data === undefined) return res.status(500).json({ message: 'No data set by handler' })
     return res.status(201).json(transformResult(data))
   }
@@ -242,76 +322,76 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
     const openapiJsonPath = basePath ? \`\${basePath}/openapi.json\` : '/openapi.json'
     const openapiYamlPath = basePath ? \`\${basePath}/openapi.yaml\` : '/openapi.yaml'
     router.get(openapiJsonPath, (_req, res) => {
-      const spec = buildModelOpenApi('${modelName}', MODEL_FIELDS as any, MODEL_ENUMS as any, config, { format: 'json' })
+      const spec = buildModelOpenApi('${modelName}', MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1], MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2], config, { format: 'json' })
       res.json(spec)
     })
     router.get(openapiYamlPath, (_req, res) => {
-      const spec = buildModelOpenApi('${modelName}', MODEL_FIELDS as any, MODEL_ENUMS as any, config, { format: 'yaml' })
+      const spec = buildModelOpenApi('${modelName}', MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1], MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2], config, { format: 'yaml' })
       res.type('application/yaml').send(spec as string)
     })
   }
 
   if (config.enableAll || config.findFirst) {
-    const opConfig: any = config.findFirst || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findFirst as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first\` : '/first'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirst), ${prefix}FindFirst as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirst, 'findFirst'), ${prefix}FindFirst as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirst as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findFirstOrThrow) {
-    const opConfig: any = config.findFirstOrThrow || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findFirstOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirstOrThrow), ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirstOrThrow, 'findFirstOrThrow'), ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findManyPaginated) {
-    const opConfig: any = config.findManyPaginated || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findManyPaginated as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findManyPaginated), ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findManyPaginated, 'findManyPaginated'), ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.aggregate) {
-    const opConfig: any = config.aggregate || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.aggregate as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.aggregate), ${prefix}Aggregate as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.aggregate, 'aggregate'), ${prefix}Aggregate as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Aggregate as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.count) {
-    const opConfig: any = config.count || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.count as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/count\` : '/count'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.count), ${prefix}Count as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.count, 'count'), ${prefix}Count as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Count as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.groupBy) {
-    const opConfig: any = config.groupBy || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.groupBy as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.groupBy), ${prefix}GroupBy as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.groupBy, 'groupBy'), ${prefix}GroupBy as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}GroupBy as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findUniqueOrThrow) {
-    const opConfig: any = config.findUniqueOrThrow || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findUniqueOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUniqueOrThrow), ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUniqueOrThrow, 'findUniqueOrThrow'), ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findUnique) {
-    const opConfig: any = config.findUnique || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findUnique as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique\` : '/unique'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUnique), ${prefix}FindUnique as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUnique, 'findUnique'), ${prefix}FindUnique as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUnique as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findMany) {
-    const opConfig: any = config.findMany || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.findMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findMany), ${prefix}FindMany as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findMany, 'findMany'), ${prefix}FindMany as RequestHandler, ...after, respond)
     if (postReadsEnabled) {
       const postPath = basePath ? \`\${basePath}/read\` : '/read'
       router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindMany as RequestHandler, ...after, respond)
@@ -319,63 +399,64 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   }
 
   if (config.enableAll || config.createManyAndReturn) {
-    const opConfig: any = config.createManyAndReturn || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.createManyAndReturn as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
     router.post(path, setShape(opConfig), ...before, ${prefix}CreateManyAndReturn as RequestHandler, ...after, respondCreated)
   }
   if (config.enableAll || config.createMany) {
-    const opConfig: any = config.createMany || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.createMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/many\` : '/many'
     router.post(path, setShape(opConfig), ...before, ${prefix}CreateMany as RequestHandler, ...after, respondCreated)
   }
   if (config.enableAll || config.create) {
-    const opConfig: any = config.create || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.create as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
     router.post(path, setShape(opConfig), ...before, ${prefix}Create as RequestHandler, ...after, respondCreated)
   }
   if (config.enableAll || config.updateManyAndReturn) {
-    const opConfig: any = config.updateManyAndReturn || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.updateManyAndReturn as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
     router.put(path, setShape(opConfig), ...before, ${prefix}UpdateManyAndReturn as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.updateMany) {
-    const opConfig: any = config.updateMany || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.updateMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/many\` : '/many'
     router.put(path, setShape(opConfig), ...before, ${prefix}UpdateMany as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.update) {
-    const opConfig: any = config.update || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.update as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
     router.put(path, setShape(opConfig), ...before, ${prefix}Update as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.upsert) {
-    const opConfig: any = config.upsert || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.upsert as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
     router.patch(path, setShape(opConfig), ...before, ${prefix}Upsert as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.deleteMany) {
-    const opConfig: any = config.deleteMany || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.deleteMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/many\` : '/many'
     router.delete(path, setShape(opConfig), ...before, ${prefix}DeleteMany as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.delete) {
-    const opConfig: any = config.delete || defaultOpConfig
+    const opConfig: OperationConfigLike = (config.delete as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
     router.delete(path, setShape(opConfig), ...before, ${prefix}Delete as RequestHandler, ...after, respond)
   }
 
-  router.use((err: any, _req: Request, res: Response, next: NextFunction) => {
-    const status = typeof err.status === 'number' ? err.status : 500
-    const message = err.message || 'Internal server error'
+  router.use((err: unknown, _req: Request, res: Response, next: NextFunction) => {
+    const e = err as { status?: number; message?: string }
+    const status = typeof e.status === 'number' ? e.status : 500
+    const message = e.message || 'Internal server error'
     if (!res.headersSent) return res.status(status).json({ message })
     next(err)
   })