prisma-generator-express 1.66.0 → 1.68.0

package/dist/generators/generateRouterHono.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateHonoRouterFunction = generateHonoRouterFunction;
 const generateRouteConfigType_1 = require("./generateRouteConfigType");
 const importExt_1 = require("../utils/importExt");
+const pathCasing_1 = require("../utils/pathCasing");
 const operationDefinitions_1 = require("../copy/operationDefinitions");
 function pathExpr(suffix) {
     if (!suffix)
@@ -49,16 +50,16 @@ function emitReadOp(meta, modelName) {
     const opKind = opKindFor(meta.name);
     const postReadLine = meta.supportsPostRead
         ? meta.name === 'findMany'
-            ? `    if (postReadsEnabled) {
+            ? `    if (resolvePostReadsEnabled(config.disablePostReads, opConfig.disablePostReads)) {
       const postPath = basePath ? \`\${basePath}/read\` : '/read'
-      app.post(postPath, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware, '${opKind}'))
+      app.post(postPath, createReadRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handlerName}, parse: 'body', dropGuard, settleBeforeHooks: SETTLE_BEFORE_HOOKS }))
     }`
-            : `    if (postReadsEnabled) app.post(path, handleRead(opConfig, ${handlerName}, parseBodyAsQueryMiddleware, '${opKind}'))`
+            : `    if (resolvePostReadsEnabled(config.disablePostReads, opConfig.disablePostReads)) app.post(path, createReadRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handlerName}, parse: 'body', dropGuard, settleBeforeHooks: SETTLE_BEFORE_HOOKS }))`
         : '';
     return `  if (isEnabled(config.${meta.configKey})) {
     const opConfig = opFor('${meta.configKey}')
     const path = ${pathValue}
-    app.get(path, handleRead(opConfig, ${handlerName}, parseQueryMiddleware, '${opKind}'))
+    app.get(path, createReadRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handlerName}, parse: 'query', dropGuard, settleBeforeHooks: SETTLE_BEFORE_HOOKS }))
 ${postReadLine}
   }`;
 }
@@ -70,60 +71,57 @@ function emitWriteOp(meta, modelName) {
     return `  if (isEnabled(config.${meta.configKey})) {
     const opConfig = opFor('${meta.configKey}')
     const path = ${pathValue}
-    app.${meta.method}(path, handleWrite(opConfig, ${handlerName}, '${opKind}'))
+    app.${meta.method}(path, createWriteRoute<TCtx, TPrisma, TEnv>({ config, opConfig, opKind: '${opKind}', handler: ${handlerName}, dropGuard, settleBeforeHooks: SETTLE_BEFORE_HOOKS }))
   }`;
 }
-function generateHonoRouterFunction({ model, enums, guardShapesImport, importStyle, writeStrategy, dropGuard, }) {
+function generateHonoRouterFunction({ model, enums, guardShapesImport, clientImport, importStyle, writeStrategy, dropGuard, pathCase, }) {
     const ext = (0, importExt_1.importExt)(importStyle);
     const modelName = model.name;
-    const modelNameLower = modelName.toLowerCase();
+    const modelSegment = (0, pathCasing_1.modelPathSegment)(modelName, pathCase);
     const routerFunctionName = `${modelName}Router`;
-    const handlerImports = operationDefinitions_1.OPERATION_METADATA
-        .map((m) => `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`)
-        .join('\n');
+    const handlerImports = operationDefinitions_1.OPERATION_METADATA.map((m) => `  ${modelName}${m.name.charAt(0).toUpperCase() + m.name.slice(1)},`).join('\n');
     const readOps = operationDefinitions_1.OPERATION_METADATA.filter((m) => m.kind === 'read');
-    const writeOps = operationDefinitions_1.OPERATION_METADATA.filter((m) => m.kind === 'write' || m.kind === 'batch')
-        .filter((m) => m.name !== 'updateEach');
+    const writeOps = operationDefinitions_1.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');
+    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 {
 ${handlerImports}
 } from './${modelName}Handlers${ext}'
 import type {
   RouteConfig,
-  HonoBeforeHook,
-  HonoAfterHook,
   HonoEnvBase,
-  HonoInternalVariables,
   GeneratedHonoEnv,
-  PaginationConfig,
+  PrismaClientLike,
 } from '../routeConfig.target${ext}'
-import { parseQueryParams } from '../parseQueryParams${ext}'
-import { normalizePrefix, getEnv, sanitizeKeys, isPlainObject } from '../misc${ext}'
+import { normalizePrefix, getEnv, resolveDropGuardEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import {
-  normalizeOperation,
-  resolveOperationVariantKey,
   resolveGuardPolicy,
-  resolveGuardShapeOnce,
+  resolvePostReadsEnabled,
   validateCountSourceWhere,
-  validateOperationConfig,
   validateUpdateEachConfig,
+  warnIfUnguardedRoutes,
 } from '../routeConfig${ext}'
-import type { NormalizedOperationConfig } from '../routeConfig${ext}'
-import { transformResult } from '../operationRuntime${ext}'
-import { mapError } from '../errorMapper${ext}'
-import { formatGuardVariantResolutionError } from '../guardVariantError${ext}'
-import { mergePaginationConfig } from '../pagination${ext}'
-import { applyDroppedGuard } from '../projectionDefaults${ext}'
-import type { OpKind } from '../projectionDefaults${ext}'
+import {
+  createReadRoute,
+  createWriteRoute,
+  createUpdateEachRoute,
+  opConfigFor,
+  normalizeHonoOperation,
+  registerOpenApiRoutes,
+  sendError,
+  type HandlerContext,
+  type HonoOpConfig,
+} from '../routerParts${ext}'
+// The legacy router factory preserves pre-parts behavior: materialized-view
+// counting is registered on import. The per-op parts boundary keeps this
+// module out of opt-in small bundles.
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
-${(0, generateRouteConfigType_1.generateRouteConfigType)(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono')}
+${(0, generateRouteConfigType_1.generateRouteConfigType)(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono', clientImport)}
 const _env = getEnv()
 
 // Fixed at generation time. The \`allowE2EGuardBypass\` control decides whether the
@@ -131,243 +129,7 @@ const _env = getEnv()
 // which is upstream behaviour. See generateRouterHono.ts.
 const DROP_GUARD = ${dropGuard}
 
-/**
- * DELIBERATELY NOT RECURSIVE.
- *
- * A self-referential JSON type sent through \`c.json()\` makes Hono's response
- * inference instantiate without a fixed point, and TypeScript answers
- * "type instantiation is excessively deep" — in the emitted file, for every
- * consumer. One level is all this needs: the value is serialised, not walked.
- */
-type JsonLike = string | number | boolean | null | unknown[] | Record<string, unknown>
-
-type OperationConfigLike<TEnv extends HonoEnvBase> = {
-  before?: HonoBeforeHook<TEnv>[]
-  after?: HonoAfterHook<TEnv>[]
-  shape?: unknown
-  variants?: Record<
-    string,
-    {
-      shape?: unknown
-      before?: HonoBeforeHook<TEnv>[]
-      after?: HonoAfterHook<TEnv>[]
-    }
-  >
-  pagination?: Partial<PaginationConfig>
-}
-
-type NormalizedOp<TEnv extends HonoEnvBase> = NormalizedOperationConfig<
-  HonoBeforeHook<TEnv>,
-  HonoAfterHook<TEnv>
->
-
-function normalizeHonoOperation<TEnv extends HonoEnvBase>(
-  config: OperationConfigLike<TEnv> | undefined,
-): NormalizedOp<TEnv> {
-  return normalizeOperation<HonoBeforeHook<TEnv>, HonoAfterHook<TEnv>>(config)
-}
-
-type HandlerContext = Context<{ Variables: HonoInternalVariables }>
-
-async function parseQueryMiddleware(c: HandlerContext): Promise<void> {
-  const raw = c.req.query() as Record<string, unknown>
-  if (raw && Object.keys(raw).length > 0) {
-    c.set('parsedQuery', parseQueryParams(raw) as Record<string, unknown>)
-  }
-}
-
-async function parseBodyAsQueryMiddleware(c: HandlerContext): Promise<void> {
-  let body: unknown
-  try {
-    body = await c.req.json()
-  } catch {
-    throw new HTTPException(400, { message: 'Request body must be a JSON object' })
-  }
-  if (!body || typeof body !== 'object' || Array.isArray(body)) {
-    throw new HTTPException(400, { message: 'Request body must be a JSON object' })
-  }
-  c.set('parsedQuery', sanitizeKeys(body as Record<string, unknown>))
-}
-
-async function parseUpdateEachBodyMiddleware(c: HandlerContext): Promise<void> {
-  let body: unknown
-  try {
-    body = await c.req.json()
-  } catch {
-    throw new HTTPException(400, { message: 'updateEach body must be an array of { where, data } items' })
-  }
-  if (!Array.isArray(body)) {
-    throw new HTTPException(400, { message: 'updateEach body must be an array of { where, data } items' })
-  }
-  c.set('body', body)
-}
-
-async function parseWriteBodyMiddleware(c: HandlerContext): Promise<void> {
-  let body: unknown
-  try {
-    body = await c.req.json()
-  } catch {
-    throw new HTTPException(400, { message: 'Request body must be a JSON object' })
-  }
-  if (!body || typeof body !== 'object' || Array.isArray(body)) {
-    throw new HTTPException(400, { message: 'Request body must be a JSON object' })
-  }
-  c.set('body', body)
-}
-
-function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
-  config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv>,
-  opConfig: NormalizedOp<TEnv>,
-  opKind: OpKind,
-) {
-  const policy = resolveGuardPolicy(config)
-
-  /**
-   * The environment bypass, honoured unless the consumer turned it off.
-   *
-   * \`E2E=true\` downgrading enforcement in a deployed environment is a real
-   * hazard, and it is also upstream behaviour — so it is a control, not a
-   * decision made here.
-   */
-  const dropGuard = DROP_GUARD || (policy.allowE2EGuardBypass && _env.E2E === 'true')
-
-  return async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<void> => {
-    /**
-     * INTERNAL REQUEST STATE IS SET THROUGH A CONCRETE CONTEXT.
-     *
-     * \`GeneratedHonoEnv<TEnv>['Variables']\` is \`HonoInternalVariables & TEnv['Variables']\`,
-     * and inside this generic function TypeScript cannot know that the consumer's
-     * half does not also declare \`routeConfig\` — so setting that key straight
-     * onto \`c\` is unassignable to the intersection and the emitted router does not
-     * typecheck under \`strict\` for ANY consumer. These keys belong to this
-     * router, so they are written through the internal shape they were declared
-     * in.
-     */
-    const vars = c as unknown as HandlerContext
-
-    const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
-    if (merged) vars.set('routeConfig', { pagination: merged })
-
-    const headerName = config.guard?.variantHeader || 'x-api-variant'
-    const headerValue = c.req.header(headerName)
-    const caller = config.guard?.resolveVariant?.(c) ?? headerValue ?? undefined
-    if (typeof caller === 'string') vars.set('guardCaller', caller)
-
-    const resolution = resolveOperationVariantKey(opConfig.guardRouting, caller)
-    if (!resolution.ok) {
-      vars.set('guardVariantFailure', resolution)
-      return
-    }
-
-    const resolvedKey =
-      opConfig.guardRouting.kind === 'named'
-        ? resolution.key
-        : undefined
-    if (resolvedKey !== undefined) vars.set('guardVariantKey', resolvedKey)
-
-    if (opConfig.guardShape) {
-      const resolveCtx = typeof config.resolveContext === 'function'
-        ? () => (config.resolveContext as unknown as (ctx: Context<GeneratedHonoEnv<TEnv>>) => unknown | Promise<unknown>)(c)
-        : undefined
-
-      /**
-       * With \`validateResolvedShapes\`, resolved ONCE here and the validated value
-       * is what travels onward — see resolveGuardShapeOnce. Passing the function
-       * on would let it return a different shape when it is enforced than when it
-       * was checked.
-       *
-       * Without it the raw shape is passed through untouched, which is upstream
-       * behaviour: it is resolved at the point of use, and a function returning
-       * something unusable is not this router's business to refuse.
-       */
-      let effectiveShape: Record<string, unknown> | undefined = opConfig.guardShape
-      if (policy.validateResolvedShapes) {
-        const resolution = await resolveGuardShapeOnce(opConfig.guardShape, resolvedKey, resolveCtx)
-        if (!resolution.ok) {
-          vars.set('guardShapeFailure', resolution.problem)
-          return
-        }
-        // \`ok\` means the resolved value is a shape object; the fallback keeps the
-        // declared shape rather than storing something the context cannot hold.
-        effectiveShape = isPlainObject(resolution.shape) ? resolution.shape : opConfig.guardShape
-      }
-
-      if (!dropGuard) {
-        vars.set('guardShape', effectiveShape)
-      } else {
-        await applyDroppedGuard(
-          effectiveShape,
-          resolvedKey,
-          resolveCtx,
-          opKind,
-          {
-            readQuery: vars.get('parsedQuery'),
-            writeBody: isPlainObject(vars.get('body'))
-              ? (vars.get('body') as Record<string, unknown>)
-              : undefined,
-          },
-          () => {
-            let target = vars.get('parsedQuery')
-            if (!target) {
-              target = {}
-              vars.set('parsedQuery', target)
-            }
-            return target
-          },
-          () => {
-            let target = vars.get('body')
-            if (!isPlainObject(target)) {
-              target = {}
-              vars.set('body', target)
-            }
-            return target as Record<string, unknown>
-          },
-        )
-      }
-    }
-  }
-}
-
-async function runBeforeHooks<TEnv extends HonoEnvBase>(
-  hooks: readonly HonoBeforeHook<TEnv>[],
-  c: Context<GeneratedHonoEnv<TEnv>>,
-): Promise<Response | undefined> {
-  for (const hook of hooks) {
-    const result = await hook(c)
-    if (result instanceof Response) return result
-  }
-  return undefined
-}
-
-async function runAfterHooks<TEnv extends HonoEnvBase>(
-  hooks: readonly HonoAfterHook<TEnv>[],
-  c: Context<GeneratedHonoEnv<TEnv>>,
-): Promise<Response | undefined> {
-  for (const hook of hooks) {
-    const result = await hook(c)
-    if (result instanceof Response) return result
-  }
-  return undefined
-}
-
-function sendResult(c: HandlerContext): Response {
-  const data = c.get('resultData')
-  const status = (c.get('resultStatus') as number | undefined) ?? 200
-  if (data === undefined) {
-    throw new HTTPException(500, { message: 'No data set by handler' })
-  }
-  return c.json(transformResult(data) as JsonLike, status as ContentfulStatusCode)
-}
-
-function sendError(c: HandlerContext, error: unknown): Response {
-  if (error instanceof HTTPException) {
-    return c.json({ message: error.message }, error.status as ContentfulStatusCode)
-  }
-  const httpError = mapError(error)
-  return c.json({ message: httpError.message }, httpError.status as ContentfulStatusCode)
-}
-
-export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+export function ${routerFunctionName}<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
   validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
   validateCountSourceWhere(
     (config.findManyPaginated && typeof config.findManyPaginated === 'object' ? config.findManyPaginated : undefined)?.pagination?.countSource,
@@ -377,19 +139,36 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
   const app = new Hono<GeneratedHonoEnv<TEnv>>()
 
   const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
+  warnIfUnguardedRoutes('${modelName}', ['findMany', 'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow', 'findManyPaginated', 'count', 'aggregate', 'groupBy', 'create', 'createMany', 'createManyAndReturn', 'update', 'updateMany', 'updateManyAndReturn', 'upsert', 'delete', 'deleteMany'], config, isEnabled)
 
   const customPrefix = normalizePrefix(config.customUrlPrefix || '')
-  const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
+  const modelPrefix = config.addModelPrefix !== false ? '/${modelSegment}' : ''
   const basePath = customPrefix + modelPrefix
 
+  const POLICY = resolveGuardPolicy(config)
+  const SETTLE_BEFORE_HOOKS = POLICY.guardResolutionOrder === 'before-hooks'
+
+  /**
+   * The environment bypass, honoured unless the consumer turned it off.
+   * \`PGE_DROP_GUARD=true\` downgrading enforcement in a deployed environment is
+   * a real hazard, and it is also upstream behaviour (under its deprecated
+   * \`E2E=true\` spelling) — so it is a control, not a decision made here.
+   */
+  const dropGuard = DROP_GUARD || (POLICY.allowE2EGuardBypass && resolveDropGuardEnv(_env))
+
+  const opFor = <K extends keyof ${modelName}RouteConfig<TCtx, TPrisma, TEnv>>(
+    key: K,
+  ): HonoOpConfig<TEnv> => {
+    const raw = config[key] as unknown as Parameters<typeof normalizeHonoOperation<TEnv>>[0]
+    return opConfigFor<TEnv>(raw, '${modelName}.' + String(key), POLICY)
+  }
+
   const openApiDisabled = config.disableOpenApi === true
     || (config.disableOpenApi !== false && (
       _env.NODE_ENV === 'production'
       || _env.DISABLE_OPENAPI === 'true'
     ))
 
-  const postReadsEnabled = !config.disablePostReads
-
   let _openApiJsonCache: unknown = undefined
   const getOpenApiJson = (): unknown => {
     if (_openApiJsonCache === undefined) {
@@ -398,7 +177,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 unknown as Parameters<typeof buildModelOpenApi>[3],
-        { format: 'json', writeStrategy: '${writeStrategy}' },
+        { format: 'json', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
       )
     }
     return _openApiJsonCache
@@ -411,7 +190,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 unknown as Parameters<typeof buildModelOpenApi>[3],
-        { format: 'yaml', writeStrategy: '${writeStrategy}' },
+        { format: 'yaml', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
       ) as string
     }
     return _openApiYamlCache
@@ -429,125 +208,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
   })
 
   if (!openApiDisabled) {
-    const openapiJsonPath = basePath ? \`\${basePath}/openapi.json\` : '/openapi.json'
-    const openapiYamlPath = basePath ? \`\${basePath}/openapi.yaml\` : '/openapi.yaml'
-    app.get(openapiJsonPath, (c) => c.json(getOpenApiJson() as JsonLike))
-    app.get(openapiYamlPath, (c) => {
-      c.header('Content-Type', 'application/yaml')
-      return c.body(getOpenApiYaml())
-    })
-  }
-
-  const POLICY = resolveGuardPolicy(config)
-  const SETTLE_BEFORE_HOOKS = POLICY.guardResolutionOrder === 'before-hooks'
-
-  /**
-   * The guard-resolution failures, raised in one place so both handlers and both
-   * orderings share exactly one definition of what a failure is.
-   *
-   * WHERE it is called is the behavioural difference, and it is the
-   * \`guardResolutionOrder\` control. \`'before-hooks'\` runs it before any operation
-   * hook, because a hook that returns a Response — an auth gate, a cache, a
-   * short-circuit for a known caller — would otherwise answer a request whose
-   * guard was never established. \`'after-hooks'\` is upstream behaviour.
-   *
-   * \`guardShapeFailure\` is only ever set when \`validateResolvedShapes\` is on, so
-   * that branch is inert rather than merely unreached when it is off.
-   */
-  const settleGuard = (c: Context<GeneratedHonoEnv<TEnv>>): void => {
-    const vars = c as unknown as HandlerContext
-    const failure = vars.get('guardVariantFailure')
-    if (failure) {
-      throw new HTTPException(400, {
-        message: formatGuardVariantResolutionError(failure),
-      })
-    }
-
-    const shapeFailure = vars.get('guardShapeFailure')
-    if (shapeFailure) {
-      throw new HTTPException(500, {
-        message: 'guard shape could not be resolved: ' + shapeFailure,
-      })
-    }
-  }
-
-  const handleRead = (
-    opConfig: NormalizedOp<TEnv>,
-    handlerFn: (c: HandlerContext) => Promise<void>,
-    parseFn: (c: HandlerContext) => Promise<void>,
-    opKind: OpKind,
-  ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
-    try {
-      await parseFn(c as unknown as HandlerContext)
-      await makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig, opKind)(c)
-
-      // Settled BEFORE any hook can answer the request, when asked for.
-      if (SETTLE_BEFORE_HOOKS) settleGuard(c)
-
-      const operationBefore = await runBeforeHooks<TEnv>(opConfig.operationBefore, c)
-      if (operationBefore) return operationBefore
-
-      // Upstream order: hooks first, guard failure after.
-      if (!SETTLE_BEFORE_HOOKS) settleGuard(c)
-
-      const key = (c as unknown as HandlerContext).get('guardVariantKey')
-      const variantHooks =
-        key !== undefined ? opConfig.variantHooks[key] : undefined
-
-      const variantBefore = await runBeforeHooks<TEnv>(variantHooks?.before ?? [], c)
-      if (variantBefore) return variantBefore
-      await handlerFn(c as unknown as HandlerContext)
-      const variantAfter = await runAfterHooks<TEnv>(variantHooks?.after ?? [], c)
-      if (variantAfter) return variantAfter
-      const operationAfter = await runAfterHooks<TEnv>(opConfig.operationAfter, c)
-      if (operationAfter) return operationAfter
-      return sendResult(c as unknown as HandlerContext)
-    } catch (error: unknown) {
-      return sendError(c as unknown as HandlerContext, error)
-    }
-  }
-
-  const handleWrite = (
-    opConfig: NormalizedOp<TEnv>,
-    handlerFn: (c: HandlerContext) => Promise<void>,
-    opKind: OpKind,
-  ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
-    try {
-      await parseWriteBodyMiddleware(c as unknown as HandlerContext)
-      await makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig, opKind)(c)
-
-      // Settled BEFORE any hook can answer the request, when asked for.
-      if (SETTLE_BEFORE_HOOKS) settleGuard(c)
-
-      const operationBefore = await runBeforeHooks<TEnv>(opConfig.operationBefore, c)
-      if (operationBefore) return operationBefore
-
-      // Upstream order: hooks first, guard failure after.
-      if (!SETTLE_BEFORE_HOOKS) settleGuard(c)
-
-      const key = (c as unknown as HandlerContext).get('guardVariantKey')
-      const variantHooks =
-        key !== undefined ? opConfig.variantHooks[key] : undefined
-
-      const variantBefore = await runBeforeHooks<TEnv>(variantHooks?.before ?? [], c)
-      if (variantBefore) return variantBefore
-      await handlerFn(c as unknown as HandlerContext)
-      const variantAfter = await runAfterHooks<TEnv>(variantHooks?.after ?? [], c)
-      if (variantAfter) return variantAfter
-      const operationAfter = await runAfterHooks<TEnv>(opConfig.operationAfter, c)
-      if (operationAfter) return operationAfter
-      return sendResult(c as unknown as HandlerContext)
-    } catch (error: unknown) {
-      return sendError(c as unknown as HandlerContext, error)
-    }
-  }
-
-  const opFor = <K extends keyof ${modelName}RouteConfig<TCtx, TPrisma, TEnv>>(
-    key: K,
-  ): NormalizedOp<TEnv> => {
-    const raw = config[key] as unknown as OperationConfigLike<TEnv> | undefined
-    validateOperationConfig(raw, '${modelName}.' + String(key), POLICY)
-    return normalizeHonoOperation(raw)
+    registerOpenApiRoutes(app, basePath, getOpenApiJson, getOpenApiYaml)
   }
 
 ${readOpBlocks}
@@ -560,9 +221,6 @@ ${writeOpBlocks}
      * endpoint is a batch of { where, data } applied directly — and the only thing
      * between it and an unguarded mass mutation is a console.warn suppressed in
      * production. A warning is not a security boundary.
-     *
-     * Removing the route outright was a breaking change to a published package,
-     * so by default it registers exactly as it did, warning and all.
      */
     if (!POLICY.enableUpdateEach) {
       throw new Error(
@@ -574,9 +232,9 @@ ${writeOpBlocks}
       )
     }
 
-    const rawUpdateEach = config.updateEach as unknown as OperationConfigLike<TEnv>
+    const rawUpdateEach = config.updateEach as unknown as Parameters<typeof normalizeHonoOperation<TEnv>>[0]
     validateUpdateEachConfig(rawUpdateEach, '${modelName}.updateEach')
-    const opConfig = normalizeHonoOperation(rawUpdateEach)
+    const opConfig = normalizeHonoOperation<TEnv>(rawUpdateEach)
     if (opConfig.operationBefore.length === 0 && _env.NODE_ENV !== 'production') {
       console.warn(
         '[${modelName}Router] updateEach is enabled without a before hook. ' +
@@ -584,20 +242,7 @@ ${writeOpBlocks}
       )
     }
     const path = basePath ? \`\${basePath}/each\` : '/each'
-    app.post(path, async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
-      try {
-        await parseUpdateEachBodyMiddleware(c as unknown as HandlerContext)
-        await makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig, 'noop')(c)
-        const beforeResponse = await runBeforeHooks<TEnv>(opConfig.operationBefore, c)
-        if (beforeResponse) return beforeResponse
-        await ${modelName}UpdateEach(c as unknown as HandlerContext)
-        const afterResponse = await runAfterHooks<TEnv>(opConfig.operationAfter, c)
-        if (afterResponse) return afterResponse
-        return sendResult(c as unknown as HandlerContext)
-      } catch (error: unknown) {
-        return sendError(c as unknown as HandlerContext, error)
-      }
-    })
+    app.post(path, createUpdateEachRoute<TCtx, TPrisma, TEnv>({ config, opConfig, handler: ${modelName}UpdateEach, dropGuard }))
   }
 
   return app

package/dist/generators/generateRouterHono.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateRouterHono.js","sourceRoot":"","sources":["../../src/generators/generateRouterHono.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateRouterHono.js","sourceRoot":"","sources":["../../src/generators/generateRouterHono.ts"],"names":[],"mappings":"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"}

package/dist/generators/generateRouterPartsHono.d.ts

@@ -0,0 +1,14 @@
+import type { DMMF } from '@prisma/generator-helper';
+import type { ImportStyle } from '../utils/resolveImportStyle';
+import type { WriteStrategy } from '../constants';
+import { type PathCase } from '../utils/pathCasing';
+export declare function generateHonoRouterParts({ model, enums, guardShapesImport, clientImport, importStyle, writeStrategy, dropGuard, pathCase, }: {
+    model: DMMF.Model;
+    enums: DMMF.DatamodelEnum[];
+    guardShapesImport: string | null;
+    clientImport?: string;
+    importStyle: ImportStyle;
+    writeStrategy: WriteStrategy;
+    dropGuard: boolean;
+    pathCase: PathCase;
+}): string;