prisma-generator-express 1.43.0 → 1.45.0

package/src/copy/autoIncludePlanner.ts

@@ -45,12 +45,29 @@ export type AutoIncludePlannerInput = {
 export const DEFAULT_AUTO_INCLUDE_MAX_DEPTH = 3
 export const DEFAULT_AUTO_INCLUDE_MAX_STAGES = 20
 
+const ALLOWED_TO_ONE_ARGS = new Set(['select', 'include', 'omit'])
+const ALLOWED_TO_MANY_ARGS = new Set([
+  'select',
+  'include',
+  'omit',
+  'where',
+  'orderBy',
+  'take',
+  'skip',
+  'cursor',
+  'distinct',
+])
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== 'object') return false
   if (Array.isArray(value)) return false
   return true
 }
 
+function isPubliclySelected(projection: Record<string, unknown>, field: string): boolean {
+  return projection[field] === true
+}
+
 function hasCountKey(value: unknown): boolean {
   if (!isPlainObject(value)) return false
   return '_count' in value
@@ -117,11 +134,11 @@ function walk(
   parentArgs: Record<string, unknown>,
   depth: number,
 ): WalkResult {
-  if (depth > ctx.maxDepth) {
-    return { unsupportedReason: 'depth exceeds maxDepth=' + ctx.maxDepth }
+  if (depth >= ctx.maxDepth) {
+    return { unsupportedReason: 'nested depth reached maxDepth=' + ctx.maxDepth }
   }
-  if (ctx.stages.length > ctx.maxStages) {
-    return { unsupportedReason: 'stages exceed maxStages=' + ctx.maxStages }
+  if (ctx.stages.length >= ctx.maxStages) {
+    return { unsupportedReason: 'stages reached maxStages=' + ctx.maxStages }
   }
 
   const model = ctx.models[modelName]
@@ -154,12 +171,17 @@ function walk(
   const isSelectMode = isPlainObject(select)
   const localOmit = isPlainObject(omit) ? omit : null
   const updatedProjection: Record<string, unknown> = {}
-  const userFields = new Set(Object.keys(projection))
 
   const relationBranches: Array<{ name: string; value: unknown }> = []
 
   for (const [key, value] of Object.entries(projection)) {
     if (model.relations[key]) {
+      if (value === false || value === null || value === undefined) {
+        if (isSelectMode) {
+          updatedProjection[key] = value
+        }
+        continue
+      }
       relationBranches.push({ name: key, value })
     } else {
       updatedProjection[key] = value
@@ -171,6 +193,10 @@ function walk(
   }
 
   for (const branch of relationBranches) {
+    if (ctx.stages.length >= ctx.maxStages) {
+      return { unsupportedReason: 'stages reached maxStages=' + ctx.maxStages }
+    }
+
     const relation = model.relations[branch.name]
 
     if (relation.direction === 'implicitM2M') {
@@ -182,6 +208,19 @@ function walk(
     if (relation.parentLinkFields.length !== relation.childLinkFields.length) {
       return { unsupportedReason: 'mismatched link field counts for ' + relation.name }
     }
+    if (!ctx.models[relation.type]) {
+      return {
+        unsupportedReason: 'target model ' + relation.type +
+          ' not in relation metadata for ' + (parentPath ? parentPath + '.' : '') + branch.name,
+      }
+    }
+
+    if (branch.value !== true && !isPlainObject(branch.value)) {
+      return {
+        unsupportedReason: 'invalid relation projection value for ' + branch.name +
+          ' (expected true or plain object)',
+      }
+    }
 
     for (const linkField of relation.parentLinkFields) {
       if (localOmit && localOmit[linkField] === true) {
@@ -191,16 +230,32 @@ function walk(
     }
 
     for (const linkField of relation.parentLinkFields) {
-      if (isSelectMode && !userFields.has(linkField)) {
+      if (isSelectMode && !isPubliclySelected(projection, linkField)) {
         updatedProjection[linkField] = true
         const fullPath = parentPath ? parentPath + '.' + linkField : linkField
         ctx.internalFieldPaths.push(fullPath)
       }
     }
 
-    const relationArgs: Record<string, unknown> = branch.value === true
-      ? {}
-      : (isPlainObject(branch.value) ? branch.value : {})
+    const relationArgs: Record<string, unknown> = branch.value === true ? {} : branch.value
+
+    const allowedArgs = relation.isList ? ALLOWED_TO_MANY_ARGS : ALLOWED_TO_ONE_ARGS
+    for (const key of Object.keys(relationArgs)) {
+      if (!allowedArgs.has(key)) {
+        return {
+          unsupportedReason: 'unsupported arg "' + key + '" for ' +
+            (relation.isList ? 'to-many' : 'to-one') + ' relation ' + relation.name,
+        }
+      }
+    }
+
+    const targetModel = ctx.models[relation.type]
+    if (hasWhereLikeRelationReference(relationArgs, targetModel)) {
+      return {
+        unsupportedReason: 'nested relation used in where/orderBy/cursor for ' +
+          relation.name + ' is not supported in MVP',
+      }
+    }
 
     const relationPath = parentPath ? parentPath + '.' + branch.name : branch.name
 

package/src/copy/autoIncludeRuntime.ts

@@ -8,6 +8,7 @@ import {
   sendSSEError,
   sendSSEProgress,
   runSingleResultSSE,
+  emitTerminalSSEError,
   setByPath,
   getDelegate,
   getExtendedClient,
@@ -35,6 +36,7 @@ export type RunAutoIncludeOptions = {
   models: Record<string, ModelRelationMap>
   variantConfig: AutoIncludeProgressiveVariantConfig
   coreQueryFn: () => Promise<unknown>
+  signal?: AbortSignal
 }
 
 function isObject(v: unknown): v is Record<string, unknown> {
@@ -99,6 +101,29 @@ function emptyResultFor(isList: boolean): unknown {
   return isList ? [] : null
 }
 
+function buildPublicForStage(
+  result: unknown,
+  internalFieldPaths: string[],
+  scopePath: string,
+): unknown {
+  if (Array.isArray(result)) {
+    return result.map((item) => {
+      if (isObject(item)) {
+        const copy: Record<string, unknown> = { ...item }
+        stripInternalAtScope(copy, internalFieldPaths, scopePath)
+        return copy
+      }
+      return item
+    })
+  }
+  if (isObject(result)) {
+    const copy: Record<string, unknown> = { ...result }
+    stripInternalAtScope(copy, internalFieldPaths, scopePath)
+    return copy
+  }
+  return result
+}
+
 async function runOneStage(options: {
   extended: unknown
   models: Record<string, ModelRelationMap>
@@ -107,32 +132,36 @@ async function runOneStage(options: {
   publicState: Record<string, unknown>
   internalFieldPaths: string[]
   res: Response
+  isAborted: () => boolean
 }): Promise<void> {
-  const { extended, models, stage, internal, publicState, internalFieldPaths, res } = options
-  if (res.writableEnded || res.destroyed) return
+  const { extended, models, stage, internal, publicState, internalFieldPaths, res, isAborted } = options
+  if (isAborted()) return
 
   const parentRaw = readPath(internal, stage.parentPath)
   if (!isObject(parentRaw)) {
+    if (stage.parentPath !== '') {
+      return
+    }
     const empty = emptyResultFor(stage.relationField.isList)
-    setByPath(publicState, stage.relationPath, empty)
-    sendSSEField(res, stage.relationPath, empty)
+    const applied = setByPath(publicState, stage.relationPath, empty)
+    if (applied) sendSSEField(res, stage.relationPath, empty)
     return
   }
 
   const linkFilter = buildLinkFilter(stage, parentRaw)
   if (!linkFilter) {
     const empty = emptyResultFor(stage.relationField.isList)
-    setByPath(publicState, stage.relationPath, empty)
-    sendSSEField(res, stage.relationPath, empty)
+    const appliedInternal = setByPath(internal, stage.relationPath, empty)
+    const appliedPublic = setByPath(publicState, stage.relationPath, empty)
+    if (appliedInternal && appliedPublic) {
+      sendSSEField(res, stage.relationPath, empty)
+    }
     return
   }
 
   const targetModel = models[stage.relationField.type]
   if (!targetModel) {
-    const empty = emptyResultFor(stage.relationField.isList)
-    setByPath(publicState, stage.relationPath, empty)
-    sendSSEField(res, stage.relationPath, empty)
-    return
+    throw new Error('Target model not in relation metadata: ' + stage.relationField.type)
   }
 
   const finalArgs: Record<string, unknown> = { ...stage.stageArgs }
@@ -142,20 +171,20 @@ async function runOneStage(options: {
   const method: 'findMany' | 'findFirst' = stage.relationField.isList ? 'findMany' : 'findFirst'
   const result = await delegate[method](finalArgs)
 
-  setByPath(internal, stage.relationPath, result)
+  if (isAborted()) return
 
-  let publicResult: unknown
-  if (Array.isArray(result)) {
-    publicResult = result
-  } else if (isObject(result)) {
-    const copy: Record<string, unknown> = { ...result }
-    stripInternalAtScope(copy, internalFieldPaths, stage.relationPath)
-    publicResult = copy
-  } else {
-    publicResult = result
+  const appliedInternal = setByPath(internal, stage.relationPath, result)
+  if (!appliedInternal) {
+    throw new Error('Failed to apply internal patch for ' + stage.relationPath)
+  }
+
+  const publicResult = buildPublicForStage(result, internalFieldPaths, stage.relationPath)
+
+  const appliedPublic = setByPath(publicState, stage.relationPath, publicResult)
+  if (!appliedPublic) {
+    throw new Error('Failed to apply public patch for ' + stage.relationPath)
   }
 
-  setByPath(publicState, stage.relationPath, publicResult)
   sendSSEField(res, stage.relationPath, publicResult)
 }
 
@@ -194,9 +223,16 @@ async function runConcurrent<T>(
 export async function runAutoIncludeProgressive(
   options: RunAutoIncludeOptions,
 ): Promise<void> {
-  const { req, res, ctx, args, baseOp, modelName, delegateKey, models, variantConfig, coreQueryFn } = options
+  const { req, res, ctx, args, baseOp, modelName, delegateKey, models, variantConfig, coreQueryFn, signal } = options
+
+  const isClientGone = () =>
+    signal?.aborted === true || res.writableEnded || res.destroyed
 
   if (ctx.guardShape) {
+    if (variantConfig.fallback === 'error') {
+      emitTerminalSSEError(res, 'auto-progressive fallback: guard shape disables auto-include')
+      return
+    }
     return runSingleResultSSE({ req, res, coreQueryFn })
   }
 
@@ -208,14 +244,7 @@ export async function runAutoIncludeProgressive(
 
   if (plan.unsupportedReason) {
     if (variantConfig.fallback === 'error') {
-      let keepalive: IntervalHandle | null = null
-      try {
-        initSSE(res)
-        keepalive = startSSEKeepalive(res)
-        sendSSEError(res, plan.unsupportedReason)
-      } finally {
-        endSSE(res, keepalive)
-      }
+      emitTerminalSSEError(res, plan.unsupportedReason)
       return
     }
     return runSingleResultSSE({ req, res, coreQueryFn })
@@ -229,15 +258,18 @@ export async function runAutoIncludeProgressive(
   try {
     initSSE(res)
     keepalive = startSSEKeepalive(res)
-    if (req.destroyed) return
+    if (isClientGone()) return
 
     const extended = await getExtendedClient(ctx)
+    if (isClientGone()) return
+
     const rootDelegate = getDelegate(extended, delegateKey)
 
     let rootResult: unknown
     try {
       rootResult = await rootDelegate[baseOp](plan.rootArgs)
     } catch (err) {
+      if (isClientGone()) return
       const code = (err as { code?: string } | null)?.code
       const isOrThrow = baseOp === 'findUniqueOrThrow' || baseOp === 'findFirstOrThrow'
       if (isOrThrow && code === 'P2025') {
@@ -249,7 +281,7 @@ export async function runAutoIncludeProgressive(
       return
     }
 
-    if (res.writableEnded || res.destroyed) return
+    if (isClientGone()) return
 
     if (rootResult === null || !isObject(rootResult)) {
       sendSSEResult(res, null)
@@ -262,17 +294,28 @@ export async function runAutoIncludeProgressive(
 
     const publicState: Record<string, unknown> = { ...publicRoot }
     for (const [k, v] of Object.entries(publicRoot)) {
+      if (isClientGone()) return
       sendSSEField(res, k, v)
     }
 
+    if (isClientGone()) return
     sendSSEProgress(res, 'root', 0, plan.stages.length)
 
     const groups = groupStagesByDepth(plan.stages)
     let completed = 0
+    let stageErrorMessage: string | null = null
+    const isAborted = () =>
+      stageErrorMessage !== null ||
+      signal?.aborted === true ||
+      res.writableEnded ||
+      res.destroyed
 
     for (const group of groups) {
-      if (res.writableEnded || res.destroyed) return
+      if (isClientGone()) return
+      if (stageErrorMessage) break
+
       await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+        if (isAborted()) return
         try {
           await runOneStage({
             extended,
@@ -282,21 +325,33 @@ export async function runAutoIncludeProgressive(
             publicState,
             internalFieldPaths: plan.internalFieldPaths,
             res,
+            isAborted,
           })
         } catch (err) {
+          if (isAborted()) return
           console.error('[auto-progressive] stage failed:', stage.relationPath, err)
-          const empty = emptyResultFor(stage.relationField.isList)
-          setByPath(publicState, stage.relationPath, empty)
-          sendSSEField(res, stage.relationPath, empty)
+          stageErrorMessage = 'Could not load progressive response'
+          return
         }
+        if (isAborted()) return
         completed++
         sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
       })
     }
 
+    if (isClientGone()) return
+
+    if (stageErrorMessage) {
+      if (!res.writableEnded && !res.destroyed) {
+        sendSSEError(res, stageErrorMessage)
+      }
+      return
+    }
+
     if (res.writableEnded || res.destroyed) return
     sendSSEResult(res, publicState)
   } catch (err) {
+    if (isClientGone()) return
     console.error('[auto-progressive] dispatch error:', err)
     if (!res.writableEnded && !res.destroyed) {
       sendSSEError(res, 'Internal server error')

package/src/copy/operationRuntime.ts

@@ -426,7 +426,7 @@ type SseWritable = {
   destroyed: boolean
 }
 
-function removeReqCloseListener(req: EventEmitterLike, listener: () => void): void {
+export function removeReqCloseListener(req: EventEmitterLike, listener: () => void): void {
   if (typeof req.off === 'function') {
     req.off('close', listener)
   } else if (typeof req.removeListener === 'function') {
@@ -509,6 +509,17 @@ export function endSSE(res: SseWritable, keepaliveHandle: IntervalHandle | null)
   }
 }
 
+export function emitTerminalSSEError(res: SseWritable, message: string): void {
+  let keepalive: IntervalHandle | null = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    sendSSEError(res, message)
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
 export interface RunSingleResultSSEOptions {
   req: EventEmitterLike
   res: SseWritable

package/src/generators/generateFastifyHandler.ts

@@ -1,5 +1,7 @@
 import { DMMF } from '@prisma/generator-helper'
 import { toCamelCase } from '../utils/strings'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
 
 const CORE_NAME_MAP: Record<string, string> = {
   delete: 'deleteUnique',
@@ -41,7 +43,9 @@ const CREATED_OPS = new Set([
 
 export function generateFastifyHandler(options: {
   model: DMMF.Model
+  importStyle: ImportStyle
 }): string {
+  const ext = importExt(options.importStyle)
   const modelName = options.model.name
   const prefix = toCamelCase(modelName)
 
@@ -75,8 +79,8 @@ export async function ${exportName}(
   }).join('\n')
 
   return `import type { FastifyRequest, FastifyReply } from 'fastify'
-import * as core from './${modelName}Core'
-import type { OperationContext } from '../operationRuntime'
+import * as core from './${modelName}Core${ext}'
+import type { OperationContext } from '../operationRuntime${ext}'
 
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown

package/src/generators/generateHonoHandler.ts

@@ -1,5 +1,7 @@
 import { DMMF } from '@prisma/generator-helper'
 import { toCamelCase } from '../utils/strings'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
 
 const CORE_NAME_MAP: Record<string, string> = {
   delete: 'deleteUnique',
@@ -41,7 +43,9 @@ const CREATED_OPS = new Set([
 
 export function generateHonoHandler(options: {
   model: DMMF.Model
+  importStyle: ImportStyle
 }): string {
+  const ext = importExt(options.importStyle)
   const modelName = options.model.name
   const prefix = toCamelCase(modelName)
 
@@ -68,8 +72,8 @@ export async function ${exportName}(c: Context<HonoEnv>): Promise<void> {
   }).join('\n')
 
   return `import type { Context } from 'hono'
-import * as core from './${modelName}Core'
-import type { OperationContext } from '../operationRuntime'
+import * as core from './${modelName}Core${ext}'
+import type { OperationContext } from '../operationRuntime${ext}'
 
 type HonoVariables = {
   prisma: unknown

package/src/generators/generateRelationMeta.ts

@@ -27,12 +27,18 @@ function findOppositeField(
   targetModelName: string,
   relationName: string | undefined,
   selfModelName: string,
+  selfFieldName: string,
 ): DMMF.Field | null {
   if (!relationName) return null
   const target = models.find((m) => m.name === targetModelName)
   if (!target) return null
+  const isSelfRelation = targetModelName === selfModelName
   return target.fields.find(
-    (f) => f.kind === 'object' && f.relationName === relationName && f.type === selfModelName,
+    (f) =>
+      f.kind === 'object' &&
+      f.relationName === relationName &&
+      f.type === selfModelName &&
+      !(isSelfRelation && f.name === selfFieldName),
   ) || null
 }
 
@@ -56,7 +62,7 @@ function computeRelation(
     }
   }
 
-  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName)
+  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName, field.name)
   if (opposite) {
     const oppFrom = (opposite.relationFromFields ?? []) as string[]
     const oppTo = (opposite.relationToFields ?? []) as string[]

package/src/generators/generateRouteConfigType.ts

@@ -42,6 +42,12 @@ function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1)
 }
 
+function requestTypeFor(target: Target): string {
+  if (target === 'fastify') return `import('fastify').FastifyRequest`
+  if (target === 'hono') return `import('hono').Context`
+  return `import('express').Request`
+}
+
 export function generateRouteConfigType(
   modelName: string,
   hookHandlerType: string,
@@ -52,6 +58,7 @@ export function generateRouteConfigType(
   const ext = importExt(importStyle)
   const m = modelName
   const supportsProgressive = target === 'express'
+  const requestType = requestTypeFor(target)
 
   const progressiveTypeImport = supportsProgressive
     ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
@@ -90,7 +97,7 @@ export function generateRouteConfigType(
     `  | ${omitKeys}\n` +
     `  | 'resolveContext'\n` +
     `> & {\n` +
-    `  resolveContext?: (request: import('express').Request) => TCtx | Promise<TCtx>\n` +
+    `  resolveContext?: (request: ${requestType}) => TCtx | Promise<TCtx>\n` +
     `${overrides}\n}\n`
   )
 }

package/src/generators/generateRouter.ts

@@ -70,7 +70,7 @@ import {
   ${prefix}GroupBy,
 } from './${modelName}Handlers${ext}'
 import * as core from './${modelName}Core${ext}'
-import type { RouteConfig } from '../routeConfig.target${ext}'
+import type { RouteConfig, QueryBuilderConfig } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
@@ -80,6 +80,10 @@ import {
   acceptsEventStream,
   runProgressiveEndpoint,
   runSingleResultSSE,
+  emitTerminalSSEError,
+  removeReqCloseListener,
+  mapError,
+  HttpError,
 } from '../operationRuntime${ext}'
 import { relationModels } from '../relationModels${ext}'
 import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
@@ -126,14 +130,14 @@ function normalizePrefix(p: string): string {
   return result
 }
 
-function isQueryBuilderEnabled(config: RouteConfig): boolean {
+function isQueryBuilderEnabled(config: { queryBuilder?: QueryBuilderConfig | false }): boolean {
   if (config.queryBuilder === false) return false
   if (typeof config.queryBuilder === 'object' && config.queryBuilder.enabled === false) return false
   if (_env.NODE_ENV === 'production') return false
   return true
 }
 
-function getQueryBuilderConfig(config: RouteConfig) {
+function getQueryBuilderConfig(config: { queryBuilder?: QueryBuilderConfig | false }) {
   if (config.queryBuilder === false) return null
   if (typeof config.queryBuilder === 'object') return config.queryBuilder
   return {}
@@ -215,7 +219,7 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
     }
   }
 
-  const maybeProgressiveSSE = (
+const maybeProgressiveSSE = (
     opConfig: OperationConfigLike,
     coreFn: (ctx: OperationContext) => Promise<unknown>,
     baseOp: string,
@@ -246,7 +250,8 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
 
           if (!isSingleRecordRead) {
             if (progressiveConfig.fallback === 'error') {
-              return next({ status: 400, message: 'autoInclude mode supports only single-record reads' })
+              emitTerminalSSEError(res, 'auto-progressive fallback: operation not single-record')
+              return
             }
             await runSingleResultSSE({
               req,
@@ -256,25 +261,40 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
             return
           }
 
-          await runAutoIncludeProgressive({
+          const ctx = buildContext(req, res)
+          const args = (locals.parsedQuery ?? {}) as Record<string, unknown>
+          const controller = new AbortController()
+          const onClose = () => controller.abort()
+          req.on('close', onClose)
+          try {
+            await runAutoIncludeProgressive({
+              req,
+              res,
+              ctx,
+              args,
+              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
+              modelName: '${modelName}',
+              delegateKey: '${delegateKey}',
+              models: relationModels,
+              variantConfig: progressiveConfig,
+              coreQueryFn: () => coreFn(ctx),
+              signal: controller.signal,
+            })
+          } finally {
+            removeReqCloseListener(req, onClose)
+          }
+          return
+        }
+
+        if (!Array.isArray(progressiveConfig.stages)) {
+          await runSingleResultSSE({
             req,
             res,
-            ctx: buildContext(req, res),
-            args: locals.parsedQuery ?? {},
-            baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
-            modelName: '${modelName}',
-            delegateKey: '${delegateKey}',
-            models: relationModels,
-            variantConfig: progressiveConfig,
             coreQueryFn: () => coreFn(buildContext(req, res)),
           })
           return
         }
 
-        if (!Array.isArray(progressiveConfig.stages)) {
-          return next({ status: 500, message: 'Progressive endpoint requires stages array' })
-        }
-
         const stageRegistry = opConfig.progressiveStages ?? {}
         const missingStage = progressiveConfig.stages.find(
           (name: string) => typeof stageRegistry[name] !== 'function',
@@ -454,10 +474,16 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   }
 
   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 })
+    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)
+    }
+    if (!res.headersSent) return res.status(httpError.status).json({ message: httpError.message })
     next(err)
   })