prisma-generator-express 1.40.0 → 1.42.0

package/src/generators/generateRouteConfigType.ts

@@ -1,26 +1,22 @@
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+import type { Target } from '../constants'
+
 const ROUTER_OPERATIONS = [
-  'findUnique',
-  'findUniqueOrThrow',
-  'findFirst',
-  'findFirstOrThrow',
-  'findMany',
-  'findManyPaginated',
-  'count',
-  'aggregate',
-  'groupBy',
-  'create',
-  'createMany',
-  'createManyAndReturn',
-  'update',
-  'updateMany',
-  'updateManyAndReturn',
-  'upsert',
-  'delete',
-  'deleteMany',
+  'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow',
+  'findMany', 'findManyPaginated', 'count', 'aggregate', 'groupBy',
+  'create', 'createMany', 'createManyAndReturn',
+  'update', 'updateMany', 'updateManyAndReturn',
+  'upsert', 'delete', 'deleteMany',
 ] as const
 
 type RouterOperation = (typeof ROUTER_OPERATIONS)[number]
 
+const READ_OPERATIONS: ReadonlySet<RouterOperation> = new Set<RouterOperation>([
+  'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow',
+  'findMany', 'findManyPaginated', 'count', 'aggregate', 'groupBy',
+])
+
 const ROUTER_OP_TO_SHAPE_OP: Record<RouterOperation, string> = {
   findUnique: 'findUnique',
   findUniqueOrThrow: 'findUniqueOrThrow',
@@ -50,40 +46,51 @@ export function generateRouteConfigType(
   modelName: string,
   hookHandlerType: string,
   guardShapesImport: string | null,
+  importStyle: ImportStyle,
+  target: Target,
 ): string {
+  const ext = importExt(importStyle)
   const m = modelName
+  const supportsProgressive = target === 'express'
 
   if (!guardShapesImport) {
-    return `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig\n`
+    return `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,
-  )
-
-  const opShapeImports = shapeOps
-    .map((op) => `${m}${capitalize(op)}ShapeInput`)
-    .join(',\n  ')
+  const shapeOps = Object.values(ROUTER_OP_TO_SHAPE_OP).filter((v, i, a) => a.indexOf(v) === i)
+  const opShapeImports = shapeOps.map((op) => `${m}${capitalize(op)}ShapeInput`).join(',\n  ')
 
   const overrides = ROUTER_OPERATIONS.map((routerOp) => {
     const shapeOp = ROUTER_OP_TO_SHAPE_OP[routerOp]
     const c = capitalize(shapeOp)
-    return (
-      `  ${routerOp}?: {\n` +
-      `    before?: ${hookHandlerType}[]\n` +
-      `    after?: ${hookHandlerType}[]\n` +
-      `    shape?: ${m}${c}ShapeInput<TCtx>\n` +
-      `  }`
-    )
+    const isRead = READ_OPERATIONS.has(routerOp)
+    const lines = [
+      `    before?: ${hookHandlerType}[]`,
+      `    after?: ${hookHandlerType}[]`,
+      `    shape?: ${m}${c}ShapeInput<TCtx>`,
+    ]
+    if (isRead && supportsProgressive) {
+      lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
+      lines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx>>`)
+    }
+    return `  ${routerOp}?: {\n${lines.join('\n')}\n  }`
   }).join('\n')
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
 
+  const progressiveTypeImport = supportsProgressive
+    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
+    : ''
+
   return (
-    `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}'\n\n` +
+    progressiveTypeImport +
+    `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
     `export type ${m}RouteConfig<TCtx = unknown> = Omit<\n` +
-    `  RouteConfig,\n` +
+    `  RouteConfig<Record<string, unknown>, TCtx>,\n` +
     `  | ${omitKeys}\n` +
-    `> & {\n${overrides}\n}\n`
+    `  | 'resolveContext'\n` +
+    `> & {\n` +
+    `  resolveContext?: (request: import('express').Request) => TCtx | Promise<TCtx>\n` +
+    `${overrides}\n}\n`
   )
 }

package/src/generators/generateRouter.ts

@@ -1,18 +1,22 @@
 import { DMMF } from '@prisma/generator-helper'
 import { toCamelCase } from '../utils/strings'
 import { generateRouteConfigType } from './generateRouteConfigType'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
 
 export function generateRouterFunction({
   model,
   enums,
-  relativeClientPath,
   guardShapesImport,
+  importStyle,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
-  relativeClientPath: string
+  relativeClientPath?: string
   guardShapesImport: string | null
+  importStyle: ImportStyle
 }): string {
+  const ext = importExt(importStyle)
   const modelName = model.name
   const prefix = toCamelCase(modelName)
   const modelNameLower = modelName.toLowerCase()
@@ -41,8 +45,9 @@ export function generateRouterFunction({
       values: e.values.map((v) => ({ name: v.name })),
     }))
 
-  return `import express, { Request, Response, NextFunction, RequestHandler } from 'express'
-import type { PrismaClient } from '${relativeClientPath}'
+  return `import express from 'express'
+import type { Request, Response, NextFunction, RequestHandler } from 'express'
+import { startQueryBuilder } from '../queryBuilder${ext}'
 import {
   ${prefix}FindUnique,
   ${prefix}FindUniqueOrThrow,
@@ -61,24 +66,52 @@ import {
   ${prefix}DeleteMany,
   ${prefix}Aggregate,
   ${prefix}Count,
-  ${prefix}GroupBy
-} from './${modelName}Handlers'
-import type { RouteConfig } from '../routeConfig.target'
-import { parseQueryParams } from '../parseQueryParams'
-import { sanitizeKeys } from '../misc'
-import { buildModelOpenApi } from '../buildModelOpenApi'
-import { transformResult } from '../operationRuntime'
-
-${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport)}
+  ${prefix}GroupBy,
+} from './${modelName}Handlers${ext}'
+import * as core from './${modelName}Core${ext}'
+import type { RouteConfig, ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'
+import { parseQueryParams } from '../parseQueryParams${ext}'
+import { sanitizeKeys } from '../misc${ext}'
+import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
+import type { OperationContext } from '../operationRuntime${ext}'
+import {
+  transformResult,
+  acceptsEventStream,
+  runProgressiveEndpoint,
+  runSingleResultSSE,
+} from '../operationRuntime${ext}'
+
+${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
 const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
 
 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?: ${modelName}RouteConfig
+  guardShape?: Record<string, unknown>
+  guardCaller?: string
+  data?: unknown
+}
+
+const defaultOpConfig: OperationConfigLike = {
+  before: [],
+  after: [],
 }
 
 function normalizePrefix(p: string): string {
@@ -103,9 +136,12 @@ 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())
 
   const customPrefix = normalizePrefix(config.customUrlPrefix || '')
@@ -113,26 +149,42 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   const basePath = customPrefix + modelPrefix
 
   const openApiDisabled = config.disableOpenApi === true
-    || (config.disableOpenApi !== false && (
-      _env.DISABLE_OPENAPI === 'true'
-      || _env.NODE_ENV === 'production'
-    ))
+    || (config.disableOpenApi !== false && (_env.DISABLE_OPENAPI === 'true' || _env.NODE_ENV === 'production'))
 
   const postReadsEnabled = !config.disablePostReads
 
   const qbEnabled = isQueryBuilderEnabled(config)
-
   if (qbEnabled) {
     const qbConfig = getQueryBuilderConfig(config)
     if (qbConfig) {
-      try { require('../queryBuilder').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 => {
+    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()
   }
@@ -141,154 +193,167 @@ 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
-      if (opConfig.shape) {
-        res.locals.guardShape = opConfig.shape
-        const caller = config.guard?.resolveVariant?.(req)
-          ?? req.get(config.guard?.variantHeader || 'x-api-variant')
-          ?? undefined
-        if (caller) {
-          res.locals.guardCaller = caller
+      const locals = readLocals(res)
+      locals.routeConfig = config
+      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: OperationConfigLike,
+    coreFn: (ctx: OperationContext) => Promise<unknown>,
+  ): 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 locals = readLocals(res)
+      const variant = locals.guardCaller
+      const progressiveConfig = variant ? opConfig.progressive?.[variant] : undefined
+
+      try {
+        if (!progressiveConfig || progressiveConfig.enabled === false) {
+          await runSingleResultSSE({
+            req,
+            res,
+            coreQueryFn: () => coreFn(buildContext(req, res)),
+          })
+          return
+        }
+
+        if (!Array.isArray(progressiveConfig.stages)) {
+          return next({ status: 500, message: 'Progressive endpoint requires stages array' })
+        }
+
+        const stageRegistry = opConfig.progressiveStages ?? {}
+        const missingStage = progressiveConfig.stages.find(
+          (name) => typeof stageRegistry[name] !== 'function',
+        )
+        if (missingStage) {
+          return next({ status: 500, message: 'Missing progressive stage: ' + missingStage })
+        }
+
+        if (typeof config.resolveContext !== 'function') {
+          return next({ status: 500, message: 'Progressive endpoint requires config.resolveContext' })
+        }
+
+        const ctx = await config.resolveContext(req)
+        await runProgressiveEndpoint({
+          req,
+          res,
+          ctx,
+          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' })
         }
       }
-      next()
     }
   }
 
   const respond: RequestHandler = (_req, res) => {
-    const data = res.locals.data
-    if (data === undefined) {
-      return res.status(500).json({ message: 'No data set by handler' })
-    }
+    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
-    if (data === undefined) {
-      return res.status(500).json({ message: 'No data set by handler' })
-    }
+    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))
   }
 
   if (!openApiDisabled) {
     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 = 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, ${prefix}FindFirst as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirst as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}Aggregate as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Aggregate as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}Count as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Count as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}GroupBy as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}GroupBy as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}FindUnique as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUnique as RequestHandler, ...after, respond)
-    }
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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 = 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, ${prefix}FindMany as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.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)
@@ -296,74 +361,65 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   }
 
   if (config.enableAll || config.createManyAndReturn) {
-    const opConfig = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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'
-    if (!res.headersSent) {
-      return res.status(status).json({ message })
-    }
+  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)
   })