prisma-generator-express 1.56.4 → 1.58.0

package/src/generators/generateRouteConfigType.ts

@@ -4,18 +4,38 @@ import type { Target } from '../constants'
 import { capitalize } from '../utils/strings'
 
 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',
+  'findUnique',
+  'findUniqueOrThrow',
+  'findFirst',
+  'findFirstOrThrow',
+  'findMany',
+  'findManyPaginated',
+  'count',
+  'aggregate',
+  'groupBy',
 ])
 
 const ROUTER_OP_TO_SHAPE_OP: Record<RouterOperation, string> = {
@@ -62,8 +82,13 @@ function routeConfigBaseFor(target: Target): string {
   return `RouteConfig<Record<string, unknown>, TCtx>`
 }
 
-function hookHandlerTypeRef(target: Target, hookHandlerType: string): string {
-  if (target === 'hono') return `${hookHandlerType}<TEnv>`
+function beforeHookRef(target: Target, hookHandlerType: string): string {
+  if (target === 'hono') return `HonoBeforeHook<TEnv>`
+  return hookHandlerType
+}
+
+function afterHookRef(target: Target, hookHandlerType: string): string {
+  if (target === 'hono') return `HonoAfterHook<TEnv>`
   return hookHandlerType
 }
 
@@ -80,7 +105,8 @@ export function generateRouteConfigType(
 
   const generics = configGenericsFor(target)
   const baseConfig = routeConfigBaseFor(target)
-  const hookRef = hookHandlerTypeRef(target, hookHandlerType)
+  const beforeRef = beforeHookRef(target, hookHandlerType)
+  const afterRef = afterHookRef(target, hookHandlerType)
   const requestType = requestTypeFor(target)
 
   const progressiveTypeImport = supportsProgressive
@@ -88,27 +114,36 @@ export function generateRouteConfigType(
     : ''
 
   if (!guardShapesImport) {
-    return progressiveTypeImport + `export type ${m}RouteConfig${generics} = ${baseConfig}\n`
+    return (
+      progressiveTypeImport +
+      `export type ${m}RouteConfig${generics} = ${baseConfig}\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)
     const isRead = READ_OPERATIONS.has(routerOp)
     const lines = [
-      `    before?: ${hookRef}[]`,
-      `    after?: ${hookRef}[]`,
+      `    before?: ${beforeRef}[]`,
+      `    after?: ${afterRef}[]`,
       `    shape?: ${m}${c}ShapeInput<TCtx>`,
       `    pagination?: Partial<PaginationConfig>`,
     ]
     if (isRead && supportsProgressive) {
       lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
-      lines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`)
+      lines.push(
+        `    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`,
+      )
     }
-    return `  ${routerOp}?: {\n${lines.join('\n')}\n  }`
+    return `  ${routerOp}?: {\n${lines.join('\n')}\n  } | false`
   }).join('\n')
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')

package/src/generators/generateRouter.ts

@@ -11,6 +11,7 @@ export function generateRouterFunction({
   importStyle,
   writeStrategy,
   findManyPaginatedMode,
+  dropGuard,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
@@ -18,6 +19,7 @@ export function generateRouterFunction({
   importStyle: ImportStyle
   writeStrategy: WriteStrategy
   findManyPaginatedMode: FindManyPaginatedMode
+  dropGuard: boolean
 }): string {
   const ext = importExt(importStyle)
   const modelName = model.name
@@ -82,6 +84,7 @@ import type {
 import { parseQueryParams } from '../parseQueryParams${ext}'
 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,
@@ -102,6 +105,7 @@ 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
@@ -152,8 +156,16 @@ function readLocals(res: Response): LocalsBag {
 }
 
 export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${modelName}RouteConfig<TCtx, TPrisma> = {}) {
+  validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
+  validateCountSourceWhere(
+    (config.findManyPaginated && typeof config.findManyPaginated === 'object' ? config.findManyPaginated : undefined)?.pagination?.countSource,
+    '${modelName} findManyPaginated pagination',
+  )
+
   const router = express.Router()
 
+  const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
+
   const customPrefix = normalizePrefix(config.customUrlPrefix || '')
   const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
   const basePath = customPrefix + modelPrefix
@@ -163,24 +175,32 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
 
   const postReadsEnabled = !config.disablePostReads
 
-  const openApiJsonSpec = openApiDisabled
-    ? null
-    : buildModelOpenApi(
+  let _openApiJsonCache: unknown = undefined
+  const getOpenApiJson = (): unknown => {
+    if (_openApiJsonCache === undefined) {
+      _openApiJsonCache = buildModelOpenApi(
         '${modelName}',
         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 },
       )
-  const openApiYamlSpec = openApiDisabled
-    ? null
-    : buildModelOpenApi(
+    }
+    return _openApiJsonCache
+  }
+  let _openApiYamlCache: string | undefined = undefined
+  const getOpenApiYaml = (): string => {
+    if (_openApiYamlCache === undefined) {
+      _openApiYamlCache = buildModelOpenApi(
         '${modelName}',
         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 },
-      )
+      ) as string
+    }
+    return _openApiYamlCache
+  }
 
   const qbEnabled = isQueryBuilderEnabled(config)
   if (qbEnabled) {
@@ -221,7 +241,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
 
   const parseBodyAsQuery: RequestHandler = (req, res, next) => {
     if (!req.body || typeof req.body !== 'object' || Array.isArray(req.body)) {
-      return next({ status: 400, message: 'Request body must be a JSON object' })
+      return next(new HttpError(400, 'Request body must be a JSON object'))
     }
     readLocals(res).parsedQuery = sanitizeKeys(req.body as Record<string, unknown>)
     next()
@@ -238,7 +258,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
       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
+      if (opConfig.shape && !DROP_GUARD) locals.guardShape = opConfig.shape
       next()
     }
   }
@@ -325,11 +345,13 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
           (name: string) => typeof stageRegistry[name] !== 'function',
         )
         if (missingStage) {
-          return next({ status: 500, message: 'Missing progressive stage: ' + missingStage })
+          emitTerminalSSEError(res, 'Missing progressive stage: ' + missingStage)
+          return
         }
 
         if (typeof config.resolveContext !== 'function') {
-          return next({ status: 500, message: 'Progressive endpoint requires config.resolveContext' })
+          emitTerminalSSEError(res, 'Progressive endpoint requires config.resolveContext')
+          return
         }
 
         const ctx = await config.resolveContext(req)
@@ -344,8 +366,8 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         })
       } catch (err) {
         console.error('[progressive] dispatch error:', err)
-        if (!res.headersSent) {
-          return next({ status: 500, message: 'Internal server error' })
+        if (!res.headersSent && !res.writableEnded) {
+          emitTerminalSSEError(res, 'Internal server error')
         }
       }
     }
@@ -367,70 +389,70 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     const openapiJsonPath = basePath ? \`\${basePath}/openapi.json\` : '/openapi.json'
     const openapiYamlPath = basePath ? \`\${basePath}/openapi.yaml\` : '/openapi.yaml'
     router.get(openapiJsonPath, (_req, res) => {
-      res.json(openApiJsonSpec)
+      res.json(getOpenApiJson())
     })
     router.get(openapiYamlPath, (_req, res) => {
-      res.type('application/yaml').send(openApiYamlSpec as string)
+      res.type('application/yaml').send(getOpenApiYaml())
     })
   }
 
-  if (config.enableAll || config.findFirst) {
+  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 (config.enableAll || config.findFirstOrThrow) {
+  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 (config.enableAll || config.findManyPaginated) {
+  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 (config.enableAll || config.aggregate) {
+  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 (config.enableAll || config.count) {
+  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 (config.enableAll || config.groupBy) {
+  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 (config.enableAll || config.findUniqueOrThrow) {
+  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 (config.enableAll || config.findUnique) {
+  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 (config.enableAll || config.findMany) {
+  if (isEnabled(config.findMany)) {
     const opConfig: OperationConfigLike = (config.findMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
@@ -441,55 +463,55 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     }
   }
 
-  if (config.enableAll || config.createManyAndReturn) {
+  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 (config.enableAll || config.createMany) {
+  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 (config.enableAll || config.create) {
+  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 (config.enableAll || config.updateManyAndReturn) {
+  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 (config.enableAll || config.updateMany) {
+  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 (config.enableAll || config.update) {
+  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 (config.enableAll || config.upsert) {
+  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 (config.enableAll || config.deleteMany) {
+  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 (config.enableAll || config.delete) {
+  if (isEnabled(config.delete)) {
     const opConfig: OperationConfigLike = (config.delete as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
@@ -497,6 +519,12 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   }
   if (config.updateEach) {
     const opConfig: OperationConfigLike = (config.updateEach as OperationConfigLike | undefined) ?? defaultOpConfig
+    if ((!opConfig.before || opConfig.before.length === 0) && _env.NODE_ENV !== 'production') {
+      console.warn(
+        '[${modelName}Router] updateEach is enabled without a before hook. ' +
+        'This endpoint bypasses guard shapes and should be protected by authentication middleware.',
+      )
+    }
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/each\` : '/each'
     router.post(