prisma-generator-express 1.59.0 → 1.60.0

package/src/generators/generateModelMetadata.ts

@@ -0,0 +1,92 @@
+import { DMMF } from '@prisma/generator-helper'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+
+function exampleValueForType(fieldType: string): unknown {
+  switch (fieldType) {
+    case 'String': return 'example'
+    case 'Int': return 1
+    case 'BigInt': return '1'
+    case 'Float': return 1.0
+    case 'Decimal': return '1.0'
+    case 'Boolean': return true
+    case 'DateTime': return '2025-01-01T00:00:00.000Z'
+    case 'Json': return {}
+    case 'Bytes': return 'base64data'
+    default: return 'example'
+  }
+}
+
+export interface GenerateModelMetadataOptions {
+  model: DMMF.Model
+  enums: DMMF.DatamodelEnum[]
+  importStyle: ImportStyle
+}
+
+export function generateModelMetadata(options: GenerateModelMetadataOptions): string {
+  const ext = importExt(options.importStyle)
+  const { model, enums } = options
+  const modelName = model.name
+
+  const fieldsMeta = model.fields.map((f: any) => ({
+    name: f.name,
+    kind: f.kind,
+    type: f.type,
+    isList: f.isList,
+    isRequired: f.isRequired,
+    hasDefaultValue: f.hasDefaultValue,
+    isUpdatedAt: Boolean(f.isUpdatedAt),
+    documentation: f.documentation ?? null,
+    isId: Boolean(f.isId),
+    isUnique: Boolean(f.isUnique),
+    relationFromFields: f.relationFromFields,
+  }))
+
+  const referencedEnumTypes = new Set(
+    model.fields.filter((f: any) => f.kind === 'enum').map((f: any) => f.type),
+  )
+
+  const enumsMeta = enums
+    .filter((e) => referencedEnumTypes.has(e.name))
+    .map((e) => ({
+      name: e.name,
+      values: e.values.map((v) => ({ name: v.name })),
+    }))
+
+  const exampleValues: Record<string, unknown> = {}
+  for (const f of model.fields as any[]) {
+    if (f.isId || f.isUnique || f.kind === 'scalar' || f.kind === 'enum') {
+      if (f.kind === 'enum') {
+        const enumDef = enums.find((e) => e.name === f.type)
+        exampleValues[f.name] = enumDef?.values[0]?.name || 'VALUE'
+      } else {
+        exampleValues[f.name] = exampleValueForType(f.type)
+      }
+    }
+  }
+
+  const compoundId =
+    model.primaryKey && model.primaryKey.fields.length > 1
+      ? { fields: model.primaryKey.fields }
+      : null
+
+  const compoundUniques = ((model as any).uniqueIndexes || [])
+    .filter((idx: any) => idx.fields && idx.fields.length > 1)
+    .map((idx: any) => ({
+      name: idx.name || idx.fields.join('_'),
+      fields: idx.fields,
+    }))
+
+  return `import type { FieldMeta, EnumMeta } from '../docsRenderer${ext}'
+
+export const MODEL_FIELDS: FieldMeta[] = ${JSON.stringify(fieldsMeta, null, 2)}
+
+export const MODEL_ENUMS: EnumMeta[] = ${JSON.stringify(enumsMeta, null, 2)}
+
+export const COMPOUND_ID: { fields: string[] } | null = ${JSON.stringify(compoundId)}
+
+export const COMPOUND_UNIQUES: { name: string; fields: string[] }[] = ${JSON.stringify(compoundUniques)}
+
+export const EXAMPLE_VALUES: Record<string, unknown> = ${JSON.stringify(exampleValues, null, 2)}
+`
+}

package/src/generators/generateOperationCore.ts

@@ -10,28 +10,21 @@ export interface ModelCoreOptions {
   findManyPaginatedMode: FindManyPaginatedMode
 }
 
-type WriteOpDecision =
-  | { mode: 'normal'; method: string }
-  | { mode: 'redirect'; method: string }
-  | { mode: 'throw' }
+type WriteOpDecision = { throw?: true; method: string }
 
 function decideWriteOp(
   name: string,
   defaultMethod: string,
   strategy: WriteStrategy,
 ): WriteOpDecision {
-  if (strategy === 'regular') {
-    return { mode: 'normal', method: defaultMethod }
+  if (strategy === 'throwOnNonReturning' && (name === 'createMany' || name === 'updateMany')) {
+    return { throw: true, method: defaultMethod }
   }
-  if (strategy === 'throwOnNonReturning') {
-    if (name === 'createMany' || name === 'updateMany') {
-      return { mode: 'throw' }
-    }
-    return { mode: 'normal', method: defaultMethod }
+  if (strategy === 'forceReturn') {
+    if (name === 'createMany') return { method: 'createManyAndReturn' }
+    if (name === 'updateMany') return { method: 'updateManyAndReturn' }
   }
-  if (name === 'createMany') return { mode: 'redirect', method: 'createManyAndReturn' }
-  if (name === 'updateMany') return { mode: 'redirect', method: 'updateManyAndReturn' }
-  return { mode: 'normal', method: defaultMethod }
+  return { method: defaultMethod }
 }
 
 function renderPaginatedBody(modelNameLower: string, mode: FindManyPaginatedMode): string {
@@ -112,7 +105,7 @@ export async function ${op}(ctx: OperationContext): Promise<unknown> {
   const writeHandlers = writeOps.map((op) => {
     const decision = decideWriteOp(op.name, op.method, writeStrategy)
 
-    if (decision.mode === 'throw') {
+    if (decision.throw) {
       return `
 export async function ${op.name}(_ctx: OperationContext): Promise<unknown> {
   throw new HttpError(501, '${op.name} is disabled by writeStrategy="${writeStrategy}"')
@@ -141,16 +134,15 @@ ${validationLines}
   return `import {
   OperationContext,
   PrismaClientLike,
-  HttpError,
   getExtendedClient,
   getDelegate,
   validateBody,
   requireBodyField,
-  applyPaginationLimits,
-  assertGuard,
-  countForPagination,
-  mapError,
 } from '../operationRuntime${ext}'
+import { HttpError, mapError } from '../errorMapper${ext}'
+import { applyPaginationLimits, countForPagination } from '../pagination${ext}'
+import { assertGuard } from '../guardHelpers${ext}'
+import { mapLimited } from '../concurrency${ext}'
 
 export async function findMany(ctx: OperationContext): Promise<unknown> {
   const rawQuery = ctx.parsedQuery || {}
@@ -248,20 +240,15 @@ export async function updateEach(
   const CONCURRENCY = 8
   const results: Array<{ status: 'ok'; data: unknown } | { status: 'error'; error: string }> =
     new Array(items.length)
-  let cursor = 0
-  const workerCount = Math.min(CONCURRENCY, items.length)
-  const workers = Array.from({ length: workerCount }, async () => {
-    for (;;) {
-      const i = cursor++
-      if (i >= items.length) return
-      try {
-        results[i] = { status: 'ok', data: await delegate.update(items[i]) }
-      } catch (err) {
-        results[i] = { status: 'error', error: mapError(err).message }
-      }
+
+  await mapLimited(items, CONCURRENCY, async (item, i) => {
+    try {
+      results[i] = { status: 'ok', data: await delegate.update(item) }
+    } catch (err) {
+      results[i] = { status: 'error', error: mapError(err).message }
     }
   })
-  await Promise.all(workers)
+
   return results
 }
 `

package/src/generators/generateQueryBuilderHelper.ts

@@ -3,7 +3,7 @@ import { GeneratorOptions } from '@prisma/generator-helper'
 export function generateQueryBuilderHelper(options: GeneratorOptions): string {
   const schemaPath = options.schemaPath
     ? JSON.stringify(options.schemaPath)
-    : "require('path').resolve(process.cwd(), 'prisma/schema.prisma')"
+    : "resolve(process.cwd(), 'prisma/schema.prisma')"
 
   return `import { spawn } from 'child_process'
 import { resolve, join, dirname } from 'path'

package/src/generators/generateRouteConfigType.ts

@@ -1,62 +1,14 @@
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import type { Target } from '../constants'
-import { capitalize } from '../utils/strings'
+import { OPERATION_METADATA, READ_OPERATION_NAMES } from '../copy/operationDefinitions'
 
-const ROUTER_OPERATIONS = [
-  'findUnique',
-  'findUniqueOrThrow',
-  'findFirst',
-  'findFirstOrThrow',
-  'findMany',
-  'findManyPaginated',
-  'count',
-  'aggregate',
-  'groupBy',
-  'create',
-  'createMany',
-  'createManyAndReturn',
-  'update',
-  'updateMany',
-  'updateManyAndReturn',
-  'upsert',
-  'delete',
-  'deleteMany',
-] as const
+const ROUTER_OPERATIONS = OPERATION_METADATA
+  .filter((m) => m.name !== 'updateEach')
+  .map((m) => m.name)
 
-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',
-  findFirst: 'findFirst',
-  findFirstOrThrow: 'findFirstOrThrow',
-  findMany: 'findMany',
-  findManyPaginated: 'findManyPaginated',
-  count: 'count',
-  aggregate: 'aggregate',
-  groupBy: 'groupBy',
-  create: 'create',
-  createMany: 'createMany',
-  createManyAndReturn: 'createManyAndReturn',
-  update: 'update',
-  updateMany: 'updateMany',
-  updateManyAndReturn: 'updateManyAndReturn',
-  upsert: 'upsert',
-  delete: 'delete',
-  deleteMany: 'deleteMany',
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1)
 }
 
 function requestTypeFor(target: Target): string {
@@ -120,17 +72,14 @@ export function generateRouteConfigType(
     )
   }
 
-  const shapeOps = Object.values(ROUTER_OP_TO_SHAPE_OP).filter(
-    (v, i, a) => a.indexOf(v) === i,
-  )
+  const shapeOps = Array.from(new Set(ROUTER_OPERATIONS))
   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)
-    const isRead = READ_OPERATIONS.has(routerOp)
+    const c = capitalize(routerOp)
+    const isRead = READ_OPERATION_NAMES.has(routerOp)
     const lines = [
       `    before?: ${beforeRef}[]`,
       `    after?: ${afterRef}[]`,

package/src/generators/generateRouter.ts

@@ -3,6 +3,60 @@ import { generateRouteConfigType } from './generateRouteConfigType'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { WriteStrategy, FindManyPaginatedMode } from '../constants'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+
+interface OpEmitContext {
+  modelName: string
+  basePath: string
+  postReadsEnabled: string
+}
+
+function pathExpr(basePath: string, suffix: string): string {
+  if (!suffix) return basePath || '/'
+  if (!basePath) return `'${suffix}'`
+  return `\`\${basePath}${suffix}\``
+}
+
+function emitReadOp(
+  meta: (typeof OPERATION_METADATA)[number],
+  modelName: string,
+): string {
+  const c = meta.name.charAt(0).toUpperCase() + meta.name.slice(1)
+  const handlerName = `${modelName}${c}`
+  const pathValue = pathExpr('basePath', meta.pathSuffix)
+
+  const postReadBlock = meta.supportsPostRead
+    ? `    if (postReadsEnabled) {
+      const postPath = ${meta.name === 'findMany' ? "basePath ? `${basePath}/read` : '/read'" : `path`}
+      router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${handlerName} as RequestHandler, ...after, respond)
+    }`
+    : ''
+
+  return `  if (isEnabled(config.${meta.configKey})) {
+    const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = ${pathValue}
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.${meta.coreName}, '${meta.name}'), ${handlerName} as RequestHandler, ...after, respond)
+${postReadBlock}
+  }`
+}
+
+function emitWriteOp(
+  meta: (typeof OPERATION_METADATA)[number],
+  modelName: string,
+): string {
+  const c = meta.name.charAt(0).toUpperCase() + meta.name.slice(1)
+  const handlerName = `${modelName}${c}`
+  const pathValue = pathExpr('basePath', meta.pathSuffix)
+  const respondFn = meta.successStatus === 201 ? 'respondCreated' : 'respond'
+
+  return `  if (isEnabled(config.${meta.configKey})) {
+    const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = ${pathValue}
+    router.${meta.method}(path, setShape(opConfig), ...before, ${handlerName} as RequestHandler, ...after, ${respondFn})
+  }`
+}
 
 export function generateRouterFunction({
   model,
@@ -27,57 +81,35 @@ export function generateRouterFunction({
   const delegateKey = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const routerFunctionName = `${modelName}Router`
 
-  const fieldsMeta = model.fields.map((f) => ({
-    name: f.name,
-    kind: f.kind,
-    type: f.type,
-    isList: f.isList,
-    isRequired: f.isRequired,
-    hasDefaultValue: f.hasDefaultValue,
-    isUpdatedAt: f.isUpdatedAt ?? false,
-    documentation: f.documentation,
-    relationFromFields: f.relationFromFields,
-  }))
-
-  const referencedEnumTypes = new Set(
-    model.fields.filter((f) => f.kind === 'enum').map((f) => f.type),
+  const handlerImports = OPERATION_METADATA.filter(
+    (m) => m.name !== 'updateEach',
   )
+    .map(
+      (m) =>
+        `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`,
+    )
+    .join('\n')
 
-  const enumsMeta = enums
-    .filter((e) => referencedEnumTypes.has(e.name))
-    .map((e) => ({
-      name: e.name,
-      values: e.values.map((v) => ({ name: v.name })),
-    }))
+  const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
+  const writeOps = OPERATION_METADATA.filter(
+    (m) => m.kind === 'write' || m.kind === 'batch',
+  ).filter((m) => m.name !== 'updateEach')
+
+  const readOpBlocks = readOps.map((m) => emitReadOp(m, modelName)).join('\n\n')
+  const writeOpBlocks = writeOps
+    .map((m) => emitWriteOp(m, modelName))
+    .join('\n\n')
 
   return `import express from 'express'
 import type { Request, Response, NextFunction, RequestHandler } from 'express'
 import { startQueryBuilder } from '../queryBuilder${ext}'
 import {
-  ${modelName}FindUnique,
-  ${modelName}FindUniqueOrThrow,
-  ${modelName}FindFirst,
-  ${modelName}FindFirstOrThrow,
-  ${modelName}FindMany,
-  ${modelName}FindManyPaginated,
-  ${modelName}Create,
-  ${modelName}CreateMany,
-  ${modelName}CreateManyAndReturn,
-  ${modelName}Update,
-  ${modelName}UpdateMany,
-  ${modelName}UpdateManyAndReturn,
-  ${modelName}Upsert,
-  ${modelName}Delete,
-  ${modelName}DeleteMany,
-  ${modelName}Aggregate,
-  ${modelName}Count,
-  ${modelName}GroupBy,
+${handlerImports}
 } from './${modelName}Handlers${ext}'
 import * as core from './${modelName}Core${ext}'
 import type {
   RouteConfig,
   QueryBuilderConfig,
-  WriteStrategy,
   FindManyPaginatedMode,
   PaginationConfig,
 } from '../routeConfig.target${ext}'
@@ -86,30 +118,26 @@ import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import { validateCountSourceWhere } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
+import { transformResult } from '../operationRuntime${ext}'
+import { HttpError, mapError } from '../errorMapper${ext}'
+import { mergePaginationConfig } from '../pagination${ext}'
 import {
-  transformResult,
   acceptsEventStream,
   runProgressiveEndpoint,
   runSingleResultSSE,
   emitTerminalSSEError,
   removeReqCloseListener,
-  mergePaginationConfig,
-  mapError,
-  HttpError,
-} from '../operationRuntime${ext}'
+} from '../sse${ext}'
 import { relationModels } from '../relationModels${ext}'
 import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
 const _env = getEnv()
 
-const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
 const FIND_MANY_PAGINATED_MODE: FindManyPaginatedMode = '${findManyPaginatedMode}'
 const DROP_GUARD = ${dropGuard} || _env.E2E === 'true'
 
-const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
-const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
-
 type OperationConfigLike = {
   before?: RequestHandler[]
   after?: RequestHandler[]
@@ -183,7 +211,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as unknown as Parameters<typeof buildModelOpenApi>[3],
-        { format: 'json', writeStrategy: WRITE_STRATEGY },
+        { format: 'json', writeStrategy: '${writeStrategy}' },
       )
     }
     return _openApiJsonCache
@@ -196,7 +224,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as unknown as Parameters<typeof buildModelOpenApi>[3],
-        { format: 'yaml', writeStrategy: WRITE_STRATEGY },
+        { format: 'yaml', writeStrategy: '${writeStrategy}' },
       ) as string
     }
     return _openApiYamlCache
@@ -374,12 +402,14 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   }
 
   const respond: RequestHandler = (_req, res) => {
+    if (res.headersSent || res.writableEnded) return
     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) => {
+    if (res.headersSent || res.writableEnded) return
     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))
@@ -396,127 +426,10 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     })
   }
 
-  if (isEnabled(config.findFirst)) {
-    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, 'findFirst'), ${modelName}FindFirst as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindFirst as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.findFirstOrThrow)) {
-    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, 'findFirstOrThrow'), ${modelName}FindFirstOrThrow as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindFirstOrThrow as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.findManyPaginated)) {
-    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, 'findManyPaginated'), ${modelName}FindManyPaginated as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindManyPaginated as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.aggregate)) {
-    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, 'aggregate'), ${modelName}Aggregate as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}Aggregate as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.count)) {
-    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, 'count'), ${modelName}Count as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}Count as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.groupBy)) {
-    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, 'groupBy'), ${modelName}GroupBy as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}GroupBy as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.findUniqueOrThrow)) {
-    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, 'findUniqueOrThrow'), ${modelName}FindUniqueOrThrow as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindUniqueOrThrow as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.findUnique)) {
-    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, 'findUnique'), ${modelName}FindUnique as RequestHandler, ...after, respond)
-    if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindUnique as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.findMany)) {
-    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, 'findMany'), ${modelName}FindMany as RequestHandler, ...after, respond)
-    if (postReadsEnabled) {
-      const postPath = basePath ? \`\${basePath}/read\` : '/read'
-      router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${modelName}FindMany as RequestHandler, ...after, respond)
-    }
-  }
+${readOpBlocks}
+
+${writeOpBlocks}
 
-  if (isEnabled(config.createManyAndReturn)) {
-    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, ${modelName}CreateManyAndReturn as RequestHandler, ...after, respondCreated)
-  }
-  if (isEnabled(config.createMany)) {
-    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, ${modelName}CreateMany as RequestHandler, ...after, respondCreated)
-  }
-  if (isEnabled(config.create)) {
-    const opConfig: OperationConfigLike = (config.create as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
-    const path = basePath || '/'
-    router.post(path, setShape(opConfig), ...before, ${modelName}Create as RequestHandler, ...after, respondCreated)
-  }
-  if (isEnabled(config.updateManyAndReturn)) {
-    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, ${modelName}UpdateManyAndReturn as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.updateMany)) {
-    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, ${modelName}UpdateMany as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.update)) {
-    const opConfig: OperationConfigLike = (config.update as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
-    const path = basePath || '/'
-    router.put(path, setShape(opConfig), ...before, ${modelName}Update as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.upsert)) {
-    const opConfig: OperationConfigLike = (config.upsert as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
-    const path = basePath || '/'
-    router.patch(path, setShape(opConfig), ...before, ${modelName}Upsert as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.deleteMany)) {
-    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, ${modelName}DeleteMany as RequestHandler, ...after, respond)
-  }
-  if (isEnabled(config.delete)) {
-    const opConfig: OperationConfigLike = (config.delete as OperationConfigLike | undefined) ?? defaultOpConfig
-    const { before = [], after = [] } = opConfig
-    const path = basePath || '/'
-    router.delete(path, setShape(opConfig), ...before, ${modelName}Delete as RequestHandler, ...after, respond)
-  }
   if (config.updateEach) {
     const opConfig: OperationConfigLike = (config.updateEach as OperationConfigLike | undefined) ?? defaultOpConfig
     if ((!opConfig.before || opConfig.before.length === 0) && _env.NODE_ENV !== 'production') {
@@ -533,6 +446,9 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
       ...before,
       async (req: Request, res: Response, next: NextFunction) => {
         try {
+          if (!Array.isArray(req.body)) {
+            throw new HttpError(400, 'updateEach body must be an array of { where, data } items')
+          }
           const atomic = req.get('x-batch-atomic') === 'true'
           readLocals(res).data = await core.updateEach(buildContext(req, res), atomic)
           next()
@@ -546,15 +462,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   }
 
   router.use((err: unknown, _req: Request, res: Response, next: NextFunction) => {
-    let httpError: HttpError
-    if (err instanceof HttpError) {
-      httpError = err
-    } else if (err && typeof err === 'object' && typeof (err as { status?: number }).status === 'number') {
-      const e = err as { status: number; message?: string }
-      httpError = new HttpError(e.status, e.message || 'Internal server error')
-    } else {
-      httpError = mapError(err)
-    }
+    const httpError = mapError(err)
     if (!res.headersSent) return res.status(httpError.status).json({ message: httpError.message })
     next(err)
   })
@@ -562,4 +470,4 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   return router
 }
 `
-}
+}