prisma-generator-express 1.67.0 → 1.68.0

package/src/generators/generateRouter.ts

@@ -189,7 +189,6 @@ import { sanitizeKeys, normalizePrefix, getEnv, isPlainObject, resolveDropGuardE
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import {
   normalizeOperation,
-  resolveOperationVariantKey,
   validateCountSourceWhere,
   validateOperationConfig,
   validateUpdateEachConfig,
@@ -201,8 +200,14 @@ import type { NormalizedOperationConfig } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
 import { transformResult } from '../operationRuntime${ext}'
 import { HttpError, mapError } from '../errorMapper${ext}'
-import { formatGuardVariantResolutionError } from '../guardVariantError${ext}'
-import type { GuardVariantResolution } from '../guardVariantRouting${ext}'
+import {
+  routeOperation,
+  prepareGuardOperation,
+  settleStage,
+  classifyError,
+  memoizeContext,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 import { mergePaginationConfig } from '../pagination${ext}'
 import { acceptsNdjson, runNdjsonFindMany } from '../ndjson${ext}'
 import {
@@ -214,7 +219,6 @@ import {
 } from '../sse${ext}'
 import { relationModels } from '../relationModels${ext}'
 import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
-import { applyDroppedGuard } from '../projectionDefaults${ext}'
 import type { OpKind } from '../projectionDefaults${ext}'
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
@@ -263,12 +267,34 @@ type LocalsBag = {
   guardShape?: Record<string, unknown>
   guardCaller?: string
   operationOverride?: RuntimeOperationOverride
-  resolveOperationContext?: () => unknown | Promise<unknown>
+  getContext?: () => Promise<unknown>
   guardVariantKey?: string
-  guardVariantFailure?: Extract<GuardVariantResolution, { ok: false }>
+  routeFailure?: { ok: false; failure: HttpError }
+  guardFailure?: { ok: false; failure: HttpError }
   data?: unknown
 }
 
+function queryChannel(res: Response): ArgsChannel {
+  return {
+    read: () => readLocals(res).parsedQuery,
+    write: (next) => {
+      readLocals(res).parsedQuery = next
+    },
+  }
+}
+
+function bodyChannel(req: Request): ArgsChannel {
+  return {
+    read: () =>
+      isPlainObject(req.body)
+        ? (req.body as Record<string, unknown>)
+        : undefined,
+    write: (next) => {
+      req.body = next
+    },
+  }
+}
+
 function normalizeExpressOperation(
   config: OperationConfigLike | undefined,
 ): NormalizedOp {
@@ -372,12 +398,15 @@ function variantAfterDispatcher(opConfig: NormalizedOp): RequestHandler {
 
 function requireVariantKey(): RequestHandler {
   return (_req, res, next) => {
-    const failure = readLocals(res).guardVariantFailure
-    if (!failure) {
-      next()
+    const locals = readLocals(res)
+    try {
+      if (locals.routeFailure) settleStage(locals.routeFailure)
+      if (locals.guardFailure) settleStage(locals.guardFailure)
+    } catch (err) {
+      next(err)
       return
     }
-    next(new HttpError(400, formatGuardVariantResolutionError(failure)))
+    next()
   }
 }
 
@@ -451,7 +480,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClie
     const locals = readLocals(res)
     return {
       operationOverride: locals.operationOverride,
-      resolveOperationContext: locals.resolveOperationContext,
+      resolveOperationContext: locals.getContext,
       prisma: extReq.prisma,
       postgres: extReq.postgres,
       sqlite: extReq.sqlite,
@@ -465,11 +494,6 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClie
     }
   }
 
-  const buildResolveContext = (req: Request): (() => unknown | Promise<unknown>) | undefined => {
-    if (typeof config.resolveContext !== 'function') return undefined
-    return () => (config.resolveContext as (r: Request) => unknown | Promise<unknown>)(req)
-  }
-
   const parseQuery: RequestHandler = (req, res, next) => {
     const rawQuery = req.query
     if (rawQuery && Object.keys(rawQuery).length > 0) {
@@ -501,11 +525,10 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClie
 
   const setShape = (opConfig: NormalizedOp, opKind: OpKind): RequestHandler => {
     return async (req, res, next) => {
+      const locals = readLocals(res)
       try {
-        const locals = readLocals(res)
         locals.operationOverride = opConfig.override
-        let context: Promise<unknown> | undefined
-        locals.resolveOperationContext = () => context ??= Promise.resolve(config.resolveContext?.(req))
+        locals.getContext = memoizeContext(() => config.resolveContext?.(req))
         const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
         if (merged) {
           locals.routeConfig = { pagination: merged }
@@ -516,51 +539,34 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClie
         const caller = config.guard?.resolveVariant?.(req) ?? headerValue ?? undefined
         if (typeof caller === 'string') locals.guardCaller = caller
 
-        const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
-        if (!resolution.ok) {
-          locals.guardVariantFailure = resolution
+        const routed = routeOperation({ guardRouting: opConfig.guardRouting, caller })
+        if (!routed.ok) {
+          locals.routeFailure = routed
           next()
           return
         }
 
-        const resolvedKey =
-          opConfig.guardRouting.kind === 'named'
-            ? resolution.key
-            : undefined
-        if (resolvedKey !== undefined) locals.guardVariantKey = resolvedKey
-
-        if (opConfig.guardShape) {
-          if (!dropGuard) {
-            locals.guardShape = opConfig.guardShape
-          } else {
-            await applyDroppedGuard(
-              opConfig.guardShape,
-              resolvedKey,
-              buildResolveContext(req),
-              opKind,
-              {
-                readQuery: locals.parsedQuery,
-                writeBody: isPlainObject(req.body)
-                  ? (req.body as Record<string, unknown>)
-                  : undefined,
-              },
-              () => {
-                if (!locals.parsedQuery) locals.parsedQuery = {}
-                return locals.parsedQuery
-              },
-              () => {
-                if (!isPlainObject(req.body)) {
-                  req.body = {}
-                }
-                return req.body as Record<string, unknown>
-              },
-            )
-          }
+        if (routed.variantKey !== undefined) locals.guardVariantKey = routed.variantKey
+
+        const guard = await prepareGuardOperation(routed, {
+          guardShape: opConfig.guardShape,
+          opKind,
+          policy: { dropGuard, validateResolvedShapes: false },
+          getContext: typeof config.resolveContext === 'function' ? locals.getContext : undefined,
+          args: queryChannel(res),
+          writeArgs: bodyChannel(req),
+        })
+        if (!guard.ok) {
+          locals.guardFailure = guard
+          next()
+          return
         }
 
+        locals.guardShape = guard.guardShape
+
         next()
       } catch (err) {
-        next(mapError(err))
+        next(classifyError(err))
       }
     }
   }

package/src/generators/generateRouterFastify.ts

@@ -145,7 +145,6 @@ import { sanitizeKeys, normalizePrefix, getEnv, isPlainObject, resolveDropGuardE
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import {
   normalizeOperation,
-  resolveOperationVariantKey,
   validateCountSourceWhere,
   validateOperationConfig,
   validateUpdateEachConfig,
@@ -157,10 +156,15 @@ import type { NormalizedOperationConfig } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
 import { transformResult } from '../operationRuntime${ext}'
 import { HttpError, mapError } from '../errorMapper${ext}'
-import { formatGuardVariantResolutionError } from '../guardVariantError${ext}'
-import type { GuardVariantResolution } from '../guardVariantRouting${ext}'
 import { mergePaginationConfig } from '../pagination${ext}'
-import { applyDroppedGuard } from '../projectionDefaults${ext}'
+import {
+  routeOperation,
+  prepareGuardOperation,
+  settleStage,
+  classifyError,
+  memoizeContext,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 import type { OpKind } from '../projectionDefaults${ext}'
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
@@ -204,13 +208,36 @@ type FastifyExtended = FastifyRequest & {
   guardShape?: Record<string, unknown>
   guardCaller?: string
   operationOverride?: RuntimeOperationOverride
-  resolveOperationContext?: () => unknown | Promise<unknown>
+  getContext?: () => Promise<unknown>
   guardVariantKey?: string
-  guardVariantFailure?: Extract<GuardVariantResolution, { ok: false }>
+  routeFailure?: { ok: false; failure: HttpError }
+  guardFailure?: { ok: false; failure: HttpError }
   resultData?: unknown
   resultStatus?: number
 }
 
+function queryChannel(request: FastifyRequest): ArgsChannel {
+  const fx = request as FastifyExtended
+  return {
+    read: () => fx.parsedQuery,
+    write: (next) => {
+      fx.parsedQuery = next
+    },
+  }
+}
+
+function bodyChannel(request: FastifyRequest): ArgsChannel {
+  return {
+    read: () =>
+      isPlainObject(request.body)
+        ? (request.body as Record<string, unknown>)
+        : undefined,
+    write: (next) => {
+      ;(request as unknown as { body: unknown }).body = next
+    },
+  }
+}
+
 function normalizeFastifyOperation(
   config: OperationConfigLike | undefined,
 ): NormalizedOp {
@@ -245,14 +272,6 @@ function parseBodyAsQueryHook(request: FastifyRequest): void {
   (request as FastifyExtended).parsedQuery = sanitizeKeys(body as Record<string, unknown>)
 }
 
-function buildResolveContext<TCtx, TPrisma extends PrismaClientLike>(
-  config: ${modelName}RouteConfig<TCtx, TPrisma>,
-  request: FastifyRequest,
-): (() => unknown | Promise<unknown>) | undefined {
-  if (typeof config.resolveContext !== 'function') return undefined
-  return () => (config.resolveContext as (r: FastifyRequest) => unknown | Promise<unknown>)(request)
-}
-
 function makeShapeHook<TCtx, TPrisma extends PrismaClientLike>(
   config: ${modelName}RouteConfig<TCtx, TPrisma>,
   opConfig: NormalizedOp,
@@ -272,8 +291,7 @@ function makeShapeHook<TCtx, TPrisma extends PrismaClientLike>(
   return async (request: FastifyRequest) => {
     const fx = request as FastifyExtended
     fx.operationOverride = opConfig.override
-    let context: Promise<unknown> | undefined
-    fx.resolveOperationContext = () => context ??= Promise.resolve(config.resolveContext?.(request))
+    fx.getContext = memoizeContext(() => config.resolveContext?.(request))
     const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
     if (merged) fx.routeConfig = { pagination: merged }
 
@@ -284,46 +302,28 @@ function makeShapeHook<TCtx, TPrisma extends PrismaClientLike>(
       ?? undefined
     if (typeof caller === 'string') fx.guardCaller = caller
 
-    const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
-    if (!resolution.ok) {
-      fx.guardVariantFailure = resolution
+    const routed = routeOperation({ guardRouting: opConfig.guardRouting, caller })
+    if (!routed.ok) {
+      fx.routeFailure = routed
       return
     }
 
-    const resolvedKey =
-      opConfig.guardRouting.kind === 'named'
-        ? resolution.key
-        : undefined
-    if (resolvedKey !== undefined) fx.guardVariantKey = resolvedKey
-
-    if (opConfig.guardShape) {
-      if (!dropGuard) {
-        fx.guardShape = opConfig.guardShape
-      } else {
-        await applyDroppedGuard(
-          opConfig.guardShape,
-          resolvedKey,
-          buildResolveContext(config, request),
-          opKind,
-          {
-            readQuery: fx.parsedQuery,
-            writeBody: isPlainObject(request.body)
-              ? (request.body as Record<string, unknown>)
-              : undefined,
-          },
-          () => {
-            if (!fx.parsedQuery) fx.parsedQuery = {}
-            return fx.parsedQuery
-          },
-          () => {
-            if (!isPlainObject(request.body)) {
-              ;(request as unknown as { body: unknown }).body = {}
-            }
-            return request.body as Record<string, unknown>
-          },
-        )
-      }
+    if (routed.variantKey !== undefined) fx.guardVariantKey = routed.variantKey
+
+    const guard = await prepareGuardOperation(routed, {
+      guardShape: opConfig.guardShape,
+      opKind,
+      policy: { dropGuard, validateResolvedShapes: false },
+      getContext: typeof config.resolveContext === 'function' ? fx.getContext : undefined,
+      args: queryChannel(request),
+      writeArgs: bodyChannel(request),
+    })
+    if (!guard.ok) {
+      fx.guardFailure = guard
+      return
     }
+
+    fx.guardShape = guard.guardShape
   }
 }
 
@@ -464,12 +464,8 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma extends Pris
         if (await runHooks(opConfig.operationBefore, request, reply)) return
 
         const fx = request as FastifyExtended
-        if (fx.guardVariantFailure) {
-          throw new HttpError(
-            400,
-            formatGuardVariantResolutionError(fx.guardVariantFailure),
-          )
-        }
+        if (fx.routeFailure) settleStage(fx.routeFailure)
+        if (fx.guardFailure) settleStage(fx.guardFailure)
 
         const key = fx.guardVariantKey
         const variantHooks =
@@ -496,12 +492,8 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma extends Pris
         if (await runHooks(opConfig.operationBefore, request, reply)) return
 
         const fx = request as FastifyExtended
-        if (fx.guardVariantFailure) {
-          throw new HttpError(
-            400,
-            formatGuardVariantResolutionError(fx.guardVariantFailure),
-          )
-        }
+        if (fx.routeFailure) settleStage(fx.routeFailure)
+        if (fx.guardFailure) settleStage(fx.guardFailure)
 
         const key = fx.guardVariantKey
         const variantHooks =