prisma-generator-express 1.59.0 → 1.60.0

package/src/generators/generateRouterFastify.ts

@@ -3,6 +3,46 @@ 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'
+
+function pathExpr(suffix: string): string {
+  if (!suffix) return `basePath || '/'`
+  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(meta.pathSuffix)
+
+  const postReadLine = meta.supportsPostRead
+    ? meta.name === 'findMany'
+      ? `      if (postReadsEnabled) {
+        const postPath = basePath ? \`\${basePath}/read\` : '/read'
+        instance.post(postPath, handleRead(opConfig, ${handlerName}, parseBodyAsQueryHook))
+      }`
+      : `      if (postReadsEnabled) instance.post(path, handleRead(opConfig, ${handlerName}, parseBodyAsQueryHook))`
+    : ''
+
+  return `    if (isEnabled(config.${meta.configKey})) {
+      const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+      const path = ${pathValue}
+      instance.get(path, handleRead(opConfig, ${handlerName}, parseQueryHook))
+${postReadLine}
+    }`
+}
+
+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(meta.pathSuffix)
+
+  return `    if (isEnabled(config.${meta.configKey})) {
+      const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
+      const path = ${pathValue}
+      instance.${meta.method}(path, handleWrite(opConfig, ${handlerName}))
+    }`
+}
 
 export function generateFastifyRouterFunction({
   model,
@@ -26,56 +66,25 @@ export function generateFastifyRouterFunction({
   const modelNameLower = modelName.toLowerCase()
   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
+    .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 type { FastifyInstance, FastifyRequest, FastifyReply, FastifyError } from 'fastify'
 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,
-  ${modelName}UpdateEach,
+${handlerImports}
 } from './${modelName}Handlers${ext}'
 import type {
   RouteConfig,
   FastifyHookHandler,
-  WriteStrategy,
   FindManyPaginatedMode,
   PaginationConfig,
 } from '../routeConfig.target${ext}'
@@ -83,19 +92,18 @@ import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import { validateCountSourceWhere } from '../routeConfig${ext}'
-import { mapError, transformResult, mergePaginationConfig, HttpError, type OperationContext } from '../operationRuntime${ext}'
+import type { OperationContext } from '../operationRuntime${ext}'
+import { transformResult } from '../operationRuntime${ext}'
+import { HttpError, mapError } from '../errorMapper${ext}'
+import { mergePaginationConfig } from '../pagination${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
 ${generateRouteConfigType(modelName, 'FastifyHookHandler', guardShapesImport, importStyle, 'fastify')}
 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?: FastifyHookHandler[]
   after?: FastifyHookHandler[]
@@ -234,7 +242,7 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
           MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
           MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
           config,
-          { format: 'json', writeStrategy: WRITE_STRATEGY },
+          { format: 'json', writeStrategy: '${writeStrategy}' },
         )
       }
       return _openApiJsonCache
@@ -247,7 +255,7 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
           MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
           MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
           config,
-          { format: 'yaml', writeStrategy: WRITE_STRATEGY },
+          { format: 'yaml', writeStrategy: '${writeStrategy}' },
         ) as string
       }
       return _openApiYamlCache
@@ -271,11 +279,9 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
     })
 
     instance.setErrorHandler((error: FastifyError, _request: FastifyRequest, reply: FastifyReply) => {
-      const e = error as { status?: number; statusCode?: number; message?: string }
-      const status = e.status ?? e.statusCode ?? 500
-      const message = error.message || 'Internal server error'
+      const httpError = mapError(error)
       if (!reply.sent) {
-        reply.code(status).send({ message })
+        reply.code(httpError.status).send({ message: httpError.message })
       }
     })
 
@@ -292,7 +298,7 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
       })
     }
 
-    const handleGet = (
+    const handleRead = (
       opConfig: OperationConfigLike,
       handlerFn: (req: FastifyRequest, reply: FastifyReply) => Promise<void>,
       parseFn: (req: FastifyRequest) => void,
@@ -326,125 +332,9 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
       }
     }
 
-    if (isEnabled(config.findFirst)) {
-      const opConfig: OperationConfigLike = (config.findFirst as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/first\` : '/first'
-      instance.get(path, handleGet(opConfig, ${modelName}FindFirst, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}FindFirst, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.findFirstOrThrow)) {
-      const opConfig: OperationConfigLike = (config.findFirstOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
-      instance.get(path, handleGet(opConfig, ${modelName}FindFirstOrThrow, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}FindFirstOrThrow, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.findManyPaginated)) {
-      const opConfig: OperationConfigLike = (config.findManyPaginated as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
-      instance.get(path, handleGet(opConfig, ${modelName}FindManyPaginated, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}FindManyPaginated, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.aggregate)) {
-      const opConfig: OperationConfigLike = (config.aggregate as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
-      instance.get(path, handleGet(opConfig, ${modelName}Aggregate, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}Aggregate, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.count)) {
-      const opConfig: OperationConfigLike = (config.count as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/count\` : '/count'
-      instance.get(path, handleGet(opConfig, ${modelName}Count, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}Count, parseBodyAsQueryHook))
-    }
+${readOpBlocks}
 
-    if (isEnabled(config.groupBy)) {
-      const opConfig: OperationConfigLike = (config.groupBy as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
-      instance.get(path, handleGet(opConfig, ${modelName}GroupBy, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}GroupBy, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.findUniqueOrThrow)) {
-      const opConfig: OperationConfigLike = (config.findUniqueOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
-      instance.get(path, handleGet(opConfig, ${modelName}FindUniqueOrThrow, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}FindUniqueOrThrow, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.findUnique)) {
-      const opConfig: OperationConfigLike = (config.findUnique as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/unique\` : '/unique'
-      instance.get(path, handleGet(opConfig, ${modelName}FindUnique, parseQueryHook))
-      if (postReadsEnabled) instance.post(path, handleGet(opConfig, ${modelName}FindUnique, parseBodyAsQueryHook))
-    }
-
-    if (isEnabled(config.findMany)) {
-      const opConfig: OperationConfigLike = (config.findMany as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath || '/'
-      instance.get(path, handleGet(opConfig, ${modelName}FindMany, parseQueryHook))
-      if (postReadsEnabled) {
-        const postPath = basePath ? \`\${basePath}/read\` : '/read'
-        instance.post(postPath, handleGet(opConfig, ${modelName}FindMany, parseBodyAsQueryHook))
-      }
-    }
-
-    if (isEnabled(config.createManyAndReturn)) {
-      const opConfig: OperationConfigLike = (config.createManyAndReturn as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
-      instance.post(path, handleWrite(opConfig, ${modelName}CreateManyAndReturn))
-    }
-
-    if (isEnabled(config.createMany)) {
-      const opConfig: OperationConfigLike = (config.createMany as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/many\` : '/many'
-      instance.post(path, handleWrite(opConfig, ${modelName}CreateMany))
-    }
-
-    if (isEnabled(config.create)) {
-      const opConfig: OperationConfigLike = (config.create as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath || '/'
-      instance.post(path, handleWrite(opConfig, ${modelName}Create))
-    }
-
-    if (isEnabled(config.updateManyAndReturn)) {
-      const opConfig: OperationConfigLike = (config.updateManyAndReturn as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
-      instance.put(path, handleWrite(opConfig, ${modelName}UpdateManyAndReturn))
-    }
-
-    if (isEnabled(config.updateMany)) {
-      const opConfig: OperationConfigLike = (config.updateMany as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/many\` : '/many'
-      instance.put(path, handleWrite(opConfig, ${modelName}UpdateMany))
-    }
-
-    if (isEnabled(config.update)) {
-      const opConfig: OperationConfigLike = (config.update as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath || '/'
-      instance.put(path, handleWrite(opConfig, ${modelName}Update))
-    }
-
-    if (isEnabled(config.upsert)) {
-      const opConfig: OperationConfigLike = (config.upsert as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath || '/'
-      instance.patch(path, handleWrite(opConfig, ${modelName}Upsert))
-    }
-
-    if (isEnabled(config.deleteMany)) {
-      const opConfig: OperationConfigLike = (config.deleteMany as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath ? \`\${basePath}/many\` : '/many'
-      instance.delete(path, handleWrite(opConfig, ${modelName}DeleteMany))
-    }
-
-    if (isEnabled(config.delete)) {
-      const opConfig: OperationConfigLike = (config.delete as OperationConfigLike | undefined) ?? defaultOpConfig
-      const path = basePath || '/'
-      instance.delete(path, handleWrite(opConfig, ${modelName}Delete))
-    }
+${writeOpBlocks}
 
     if (config.updateEach) {
       const opConfig: OperationConfigLike = (config.updateEach as OperationConfigLike | undefined) ?? defaultOpConfig
@@ -457,6 +347,9 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
       const path = basePath ? \`\${basePath}/each\` : '/each'
       instance.post(path, async (request: FastifyRequest, reply: FastifyReply) => {
         try {
+          if (!Array.isArray(request.body)) {
+            throw new HttpError(400, 'updateEach body must be an array of { where, data } items')
+          }
           makeShapeHook(config, opConfig)(request)
           const { before = [], after = [] } = opConfig
           if (await runHooks(before, request, reply)) return

package/src/generators/generateRouterHono.ts

@@ -3,6 +3,46 @@ import { generateRouteConfigType } from './generateRouteConfigType'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { WriteStrategy } from '../constants'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+
+function pathExpr(suffix: string): string {
+  if (!suffix) return `basePath || '/'`
+  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(meta.pathSuffix)
+
+  const postReadLine = meta.supportsPostRead
+    ? meta.name === 'findMany'
+      ? `    if (postReadsEnabled) {
+      const postPath = basePath ? \`\${basePath}/read\` : '/read'
+      app.post(postPath, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware))
+    }`
+      : `    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware))`
+    : ''
+
+  return `  if (isEnabled(config.${meta.configKey})) {
+    const opConfig = opFor('${meta.configKey}')
+    const path = ${pathValue}
+    app.get(path, handleRead(opConfig, ${handlerName}, parseQueryMiddleware))
+${postReadLine}
+  }`
+}
+
+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(meta.pathSuffix)
+
+  return `  if (isEnabled(config.${meta.configKey})) {
+    const opConfig = opFor('${meta.configKey}')
+    const path = ${pathValue}
+    app.${meta.method}(path, handleWrite(opConfig, ${handlerName}))
+  }`
+}
 
 export function generateHonoRouterFunction({
   model,
@@ -24,53 +64,23 @@ export function generateHonoRouterFunction({
   const modelNameLower = modelName.toLowerCase()
   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
+    .map((m) => `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`)
+    .join('\n')
+
+  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 enumsMeta = enums
-    .filter((e) => referencedEnumTypes.has(e.name))
-    .map((e) => ({
-      name: e.name,
-      values: e.values.map((v) => ({ name: v.name })),
-    }))
+  const readOpBlocks = readOps.map((m) => emitReadOp(m, modelName)).join('\n\n')
+  const writeOpBlocks = writeOps.map((m) => emitWriteOp(m, modelName)).join('\n\n')
 
   return `import { Hono } from 'hono'
 import type { Context } from 'hono'
 import type { ContentfulStatusCode } from 'hono/utils/http-status'
 import { HTTPException } from 'hono/http-exception'
 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,
-  ${modelName}UpdateEach,
+${handlerImports}
 } from './${modelName}Handlers${ext}'
 import type {
   RouteConfig,
@@ -79,23 +89,20 @@ import type {
   HonoEnvBase,
   HonoInternalVariables,
   GeneratedHonoEnv,
-  WriteStrategy,
   PaginationConfig,
 } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { normalizePrefix, getEnv, sanitizeKeys } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import { validateCountSourceWhere } from '../routeConfig${ext}'
-import {
-  mapError,
-  transformResult,
-  mergePaginationConfig,
-} from '../operationRuntime${ext}'
+import { transformResult } from '../operationRuntime${ext}'
+import { mapError } from '../errorMapper${ext}'
+import { mergePaginationConfig } from '../pagination${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
 ${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono')}
 const _env = getEnv()
 
-const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
 const DROP_GUARD = ${dropGuard} || _env.E2E === 'true'
 
 type JsonLike =
@@ -106,10 +113,6 @@ type JsonLike =
   | JsonLike[]
   | { [k: string]: JsonLike }
 
-const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
-
-const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
-
 type OperationConfigLike<TEnv extends HonoEnvBase> = {
   before?: HonoBeforeHook<TEnv>[]
   after?: HonoAfterHook<TEnv>[]
@@ -259,7 +262,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as RouteConfig,
-        { format: 'json', writeStrategy: WRITE_STRATEGY },
+        { format: 'json', writeStrategy: '${writeStrategy}' },
       )
     }
     return _openApiJsonCache
@@ -272,7 +275,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as RouteConfig,
-        { format: 'yaml', writeStrategy: WRITE_STRATEGY },
+        { format: 'yaml', writeStrategy: '${writeStrategy}' },
       ) as string
     }
     return _openApiYamlCache
@@ -343,109 +346,9 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       ?? (defaultOpConfig as OperationConfigLike<TEnv>)
   }
 
-  if (isEnabled(config.findFirst)) {
-    const opConfig = opFor('findFirst')
-    const path = basePath ? \`\${basePath}/first\` : '/first'
-    app.get(path, handleRead(opConfig, ${modelName}FindFirst, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindFirst, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.findFirstOrThrow)) {
-    const opConfig = opFor('findFirstOrThrow')
-    const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
-    app.get(path, handleRead(opConfig, ${modelName}FindFirstOrThrow, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindFirstOrThrow, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.findManyPaginated)) {
-    const opConfig = opFor('findManyPaginated')
-    const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
-    app.get(path, handleRead(opConfig, ${modelName}FindManyPaginated, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindManyPaginated, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.aggregate)) {
-    const opConfig = opFor('aggregate')
-    const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
-    app.get(path, handleRead(opConfig, ${modelName}Aggregate, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}Aggregate, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.count)) {
-    const opConfig = opFor('count')
-    const path = basePath ? \`\${basePath}/count\` : '/count'
-    app.get(path, handleRead(opConfig, ${modelName}Count, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}Count, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.groupBy)) {
-    const opConfig = opFor('groupBy')
-    const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
-    app.get(path, handleRead(opConfig, ${modelName}GroupBy, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}GroupBy, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.findUniqueOrThrow)) {
-    const opConfig = opFor('findUniqueOrThrow')
-    const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
-    app.get(path, handleRead(opConfig, ${modelName}FindUniqueOrThrow, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindUniqueOrThrow, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.findUnique)) {
-    const opConfig = opFor('findUnique')
-    const path = basePath ? \`\${basePath}/unique\` : '/unique'
-    app.get(path, handleRead(opConfig, ${modelName}FindUnique, parseQueryMiddleware))
-    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindUnique, parseBodyAsQueryMiddleware))
-  }
-  if (isEnabled(config.findMany)) {
-    const opConfig = opFor('findMany')
-    const path = basePath || '/'
-    app.get(path, handleRead(opConfig, ${modelName}FindMany, parseQueryMiddleware))
-    if (postReadsEnabled) {
-      const postPath = basePath ? \`\${basePath}/read\` : '/read'
-      app.post(postPath, handleRead(opConfig, ${modelName}FindMany, parseBodyAsQueryMiddleware))
-    }
-  }
+${readOpBlocks}
 
-  if (isEnabled(config.createManyAndReturn)) {
-    const opConfig = opFor('createManyAndReturn')
-    const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
-    app.post(path, handleWrite(opConfig, ${modelName}CreateManyAndReturn))
-  }
-  if (isEnabled(config.createMany)) {
-    const opConfig = opFor('createMany')
-    const path = basePath ? \`\${basePath}/many\` : '/many'
-    app.post(path, handleWrite(opConfig, ${modelName}CreateMany))
-  }
-  if (isEnabled(config.create)) {
-    const opConfig = opFor('create')
-    const path = basePath || '/'
-    app.post(path, handleWrite(opConfig, ${modelName}Create))
-  }
-  if (isEnabled(config.updateManyAndReturn)) {
-    const opConfig = opFor('updateManyAndReturn')
-    const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
-    app.put(path, handleWrite(opConfig, ${modelName}UpdateManyAndReturn))
-  }
-  if (isEnabled(config.updateMany)) {
-    const opConfig = opFor('updateMany')
-    const path = basePath ? \`\${basePath}/many\` : '/many'
-    app.put(path, handleWrite(opConfig, ${modelName}UpdateMany))
-  }
-  if (isEnabled(config.update)) {
-    const opConfig = opFor('update')
-    const path = basePath || '/'
-    app.put(path, handleWrite(opConfig, ${modelName}Update))
-  }
-  if (isEnabled(config.upsert)) {
-    const opConfig = opFor('upsert')
-    const path = basePath || '/'
-    app.patch(path, handleWrite(opConfig, ${modelName}Upsert))
-  }
-  if (isEnabled(config.deleteMany)) {
-    const opConfig = opFor('deleteMany')
-    const path = basePath ? \`\${basePath}/many\` : '/many'
-    app.delete(path, handleWrite(opConfig, ${modelName}DeleteMany))
-  }
-  if (isEnabled(config.delete)) {
-    const opConfig = opFor('delete')
-    const path = basePath || '/'
-    app.delete(path, handleWrite(opConfig, ${modelName}Delete))
-  }
+${writeOpBlocks}
 
   if (config.updateEach) {
     const opConfig = (config.updateEach as unknown as OperationConfigLike<TEnv> | undefined) ?? (defaultOpConfig as OperationConfigLike<TEnv>)

package/src/generators/generateUnifiedHandler.ts

@@ -1,47 +1,21 @@
 import { DMMF } from '@prisma/generator-helper'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
 export interface UnifiedHandlerOptions {
   model: DMMF.Model
   importStyle: ImportStyle
 }
 
-const CORE_NAME_MAP: Record<string, string> = {
-  delete: 'deleteUnique',
-}
-
-function coreFnName(op: string): string {
-  return CORE_NAME_MAP[op] || op
-}
-
-const ALL_OPS = [
-  'findMany',
-  'findFirst',
-  'findFirstOrThrow',
-  'findUnique',
-  'findUniqueOrThrow',
-  'findManyPaginated',
-  'create',
-  'createMany',
-  'createManyAndReturn',
-  'update',
-  'updateMany',
-  'updateManyAndReturn',
-  'upsert',
-  'delete',
-  'deleteMany',
-  'aggregate',
-  'count',
-  'groupBy',
-]
-
 export function generateUnifiedHandler(options: UnifiedHandlerOptions): string {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
 
-  const handlers = ALL_OPS.map((op) => {
-    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
+  const dispatchOps = OPERATION_METADATA.filter((m) => m.name !== 'updateEach')
+
+  const handlers = dispatchOps.map((meta) => {
+    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
 
     return `
 export async function ${exportName}(
@@ -50,7 +24,7 @@ export async function ${exportName}(
   next: NextFunction,
 ) {
   try {
-    ;(res.locals as LocalsBag).data = await core.${coreFnName(op)}(buildContext(req, res))
+    ;(res.locals as LocalsBag).data = await core.${meta.coreName}(buildContext(req, res))
     next()
   } catch (error: unknown) {
     next(mapError(error))
@@ -60,7 +34,8 @@ export async function ${exportName}(
 
   return `import type { Request, Response, NextFunction } from 'express'
 import * as core from './${modelName}Core${ext}'
-import { OperationContext, mapError } from '../operationRuntime${ext}'
+import { OperationContext } from '../operationRuntime${ext}'
+import { mapError } from '../errorMapper${ext}'
 
 type ExtendedRequest = Request & {
   prisma?: unknown