prisma-generator-express 1.54.0 → 1.56.0

package/src/generators/generateFastifyHandler.ts

@@ -77,7 +77,7 @@ export async function ${exportName}(
 
   return `import type { FastifyRequest, FastifyReply } from 'fastify'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext } from '../operationRuntime${ext}'
+import type { OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
 
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown
@@ -87,6 +87,7 @@ type FastifyExtended = FastifyRequest & {
   routeConfig?: { pagination?: OperationContext['paginationConfig'] }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  findManyPaginatedMode?: FindManyPaginatedMode
   resultData?: unknown
   resultStatus?: number
 }
@@ -102,6 +103,7 @@ function buildContext(request: FastifyRequest): OperationContext {
     guardShape: req.guardShape,
     guardCaller: req.guardCaller,
     paginationConfig: req.routeConfig?.pagination,
+    findManyPaginatedMode: req.findManyPaginatedMode,
   }
 }
 ${readHandlers}

package/src/generators/generateHonoHandler.ts

@@ -70,7 +70,7 @@ export async function ${exportName}(c: Context<HonoEnv>): Promise<void> {
 
   return `import type { Context } from 'hono'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext } from '../operationRuntime${ext}'
+import type { OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
 
 type HonoVariables = {
   prisma: unknown
@@ -81,6 +81,7 @@ type HonoVariables = {
   routeConfig?: { pagination?: OperationContext['paginationConfig'] }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  findManyPaginatedMode?: FindManyPaginatedMode
   resultData?: unknown
   resultStatus?: number
 }
@@ -97,6 +98,7 @@ function buildContext(c: Context<HonoEnv>): OperationContext {
     guardShape: c.get('guardShape'),
     guardCaller: c.get('guardCaller'),
     paginationConfig: c.get('routeConfig')?.pagination,
+    findManyPaginatedMode: c.get('findManyPaginatedMode'),
   }
 }
 ${readHandlers}

package/src/generators/generateOperationCore.ts

@@ -1,16 +1,82 @@
 import { DMMF } from '@prisma/generator-helper'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
+import { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export interface ModelCoreOptions {
   model: DMMF.Model
   importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  findManyPaginatedMode: FindManyPaginatedMode
+}
+
+type WriteOpDecision =
+  | { mode: 'normal'; method: string }
+  | { mode: 'redirect'; method: string }
+  | { mode: 'throw' }
+
+function decideWriteOp(
+  name: string,
+  defaultMethod: string,
+  strategy: WriteStrategy,
+): WriteOpDecision {
+  if (strategy === 'regular') {
+    return { mode: 'normal', method: defaultMethod }
+  }
+  if (strategy === 'throwOnNonReturning') {
+    if (name === 'createMany' || name === 'updateMany') {
+      return { mode: 'throw' }
+    }
+    return { mode: 'normal', method: defaultMethod }
+  }
+  if (name === 'createMany') return { mode: 'redirect', method: 'createManyAndReturn' }
+  if (name === 'updateMany') return { mode: 'redirect', method: 'updateManyAndReturn' }
+  return { mode: 'normal', method: defaultMethod }
+}
+
+function renderPaginatedBody(modelNameLower: string, mode: FindManyPaginatedMode): string {
+  if (mode === 'transaction') {
+    return `
+  const txClient = extended as { $transaction?: <T>(fn: (tx: unknown) => Promise<T>) => Promise<T> }
+  if (typeof txClient.$transaction !== 'function') {
+    throw new HttpError(500, 'findManyPaginatedMode="transaction" requires transaction support on the Prisma client')
+  }
+
+  const txResult = await txClient.$transaction(async (tx: unknown) => {
+    const txDelegate = getDelegate(tx, '${modelNameLower}')
+    if (shape) assertGuard(txDelegate)
+    const findP = shape
+      ? (txDelegate.guard as NonNullable<typeof txDelegate.guard>)(shape, caller).findMany(query)
+      : txDelegate.findMany(query)
+    const countP = countForPagination(
+      txDelegate, query, shape, caller, distinctCountLimit, countSource, tx,
+    )
+    const [data, count] = await Promise.all([findP, countP])
+    return { data, count }
+  })
+  items = txResult.data as unknown[]
+  total = txResult.count`
+  }
+
+  return `
+  const delegate = getDelegate(extended, '${modelNameLower}')
+  if (shape) assertGuard(delegate)
+  const [data, count] = await Promise.all([
+    shape
+      ? (delegate.guard as NonNullable<typeof delegate.guard>)(shape, caller).findMany(query)
+      : delegate.findMany(query),
+    countForPagination(delegate, query, shape, caller, distinctCountLimit, countSource, extended),
+  ])
+  items = data as unknown[]
+  total = count`
 }
 
 export function generateModelCore(options: ModelCoreOptions): string {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
   const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
+  const writeStrategy = options.writeStrategy
+  const paginatedBody = renderPaginatedBody(modelNameLower, options.findManyPaginatedMode)
 
   const standardReadOps = [
     'findFirst', 'findUnique', 'findUniqueOrThrow', 'findFirstOrThrow',
@@ -44,7 +110,20 @@ export async function ${op}(ctx: OperationContext): Promise<unknown> {
   ]
 
   const writeHandlers = writeOps.map((op) => {
-    const validationLines = op.requiredFields.map((field) => `  requireBodyField(body, '${field}')`).join('\n')
+    const decision = decideWriteOp(op.name, op.method, writeStrategy)
+
+    if (decision.mode === 'throw') {
+      return `
+export async function ${op.name}(_ctx: OperationContext): Promise<unknown> {
+  throw new HttpError(501, '${op.name} is disabled by writeStrategy="${writeStrategy}"')
+}`
+    }
+
+    const method = decision.method
+    const validationLines = op.requiredFields
+      .map((field) => `  requireBodyField(body, '${field}')`)
+      .join('\n')
+
     return `
 export async function ${op.name}(ctx: OperationContext): Promise<unknown> {
   const body = validateBody(ctx.body)
@@ -53,9 +132,9 @@ ${validationLines}
   const delegate = getDelegate(extended, '${modelNameLower}')
   if (ctx.guardShape) {
     assertGuard(delegate)
-    return delegate.guard(ctx.guardShape, ctx.guardCaller).${op.method}(body)
+    return delegate.guard(ctx.guardShape, ctx.guardCaller).${method}(body)
   }
-  return delegate.${op.method}(body)
+  return delegate.${method}(body)
 }`
   }).join('\n')
 
@@ -96,45 +175,11 @@ export async function findManyPaginated(
   const shape = ctx.guardShape
   const caller = ctx.guardCaller
   const distinctCountLimit = ctx.paginationConfig?.distinctCountLimit
-  const delegate = getDelegate(extended, '${modelNameLower}')
-
-  if (shape) assertGuard(delegate)
+  const countSource = ctx.paginationConfig?.countSource
 
   let items: unknown[]
   let total: number
-
-  const txClient = extended as { $transaction?: <T>(fn: (tx: unknown) => Promise<T>) => Promise<T> }
-
-  if (shape || typeof txClient.$transaction !== 'function') {
-    const [data, count] = await Promise.all([
-      shape
-        ? (delegate.guard as NonNullable<typeof delegate.guard>)(shape, caller).findMany(query)
-        : delegate.findMany(query),
-      countForPagination(delegate, query, shape, caller, distinctCountLimit),
-    ])
-    items = data as unknown[]
-    total = count
-  } else {
-    try {
-      const txResult = await txClient.$transaction(async (tx: unknown) => {
-        const txDelegate = getDelegate(tx, '${modelNameLower}')
-        const d = await txDelegate.findMany(query)
-        const t = await countForPagination(txDelegate, query, undefined, undefined, distinctCountLimit)
-        return { d, t }
-      })
-      items = txResult.d as unknown[]
-      total = txResult.t
-    } catch (txError: unknown) {
-      const txe = txError as { message?: string; code?: string }
-      if (txe?.code === 'P2028') {
-        console.warn('[prisma-generator-express] Interactive transactions not available, pagination queries are non-atomic')
-        items = (await delegate.findMany(query)) as unknown[]
-        total = await countForPagination(delegate, query, undefined, undefined, distinctCountLimit)
-      } else {
-        throw txError
-      }
-    }
-  }
+${paginatedBody}
 
   const skip = (typeof query.skip === 'number' ? query.skip : 0)
   const takeRaw = (typeof query.take === 'number' ? query.take : items.length)

package/src/generators/generateRouteConfigType.ts

@@ -39,7 +39,6 @@ const ROUTER_OP_TO_SHAPE_OP: Record<RouterOperation, string> = {
   deleteMany: 'deleteMany',
 }
 
-
 function requestTypeFor(target: Target): string {
   if (target === 'fastify') return `import('fastify').FastifyRequest`
   if (target === 'hono') return `import('hono').Context<TEnv>`
@@ -85,13 +84,15 @@ export function generateRouteConfigType(
   const requestType = requestTypeFor(target)
 
   const progressiveTypeImport = supportsProgressive
-    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
+    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n`
     : ''
 
   if (!guardShapesImport) {
     return progressiveTypeImport + `export type ${m}RouteConfig${generics} = ${baseConfig}\n`
   }
 
+  const paginationImport = `import type { PaginationConfig } from '../routeConfig.target${ext}'\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  ')
 
@@ -103,6 +104,7 @@ export function generateRouteConfigType(
       `    before?: ${hookRef}[]`,
       `    after?: ${hookRef}[]`,
       `    shape?: ${m}${c}ShapeInput<TCtx>`,
+      `    pagination?: Partial<PaginationConfig>`,
     ]
     if (isRead && supportsProgressive) {
       lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
@@ -115,6 +117,7 @@ export function generateRouteConfigType(
 
   return (
     progressiveTypeImport +
+    paginationImport +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
     `export type ${m}RouteConfig${generics} = Omit<\n` +
     `  ${baseConfig},\n` +

package/src/generators/generateRouter.ts

@@ -2,17 +2,22 @@ import { DMMF } from '@prisma/generator-helper'
 import { generateRouteConfigType } from './generateRouteConfigType'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
+import { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export function generateRouterFunction({
   model,
   enums,
   guardShapesImport,
   importStyle,
+  writeStrategy,
+  findManyPaginatedMode,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
   guardShapesImport: string | null
   importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  findManyPaginatedMode: FindManyPaginatedMode
 }): string {
   const ext = importExt(importStyle)
   const modelName = model.name
@@ -67,7 +72,13 @@ import {
   ${modelName}GroupBy,
 } from './${modelName}Handlers${ext}'
 import * as core from './${modelName}Core${ext}'
-import type { RouteConfig, QueryBuilderConfig } from '../routeConfig.target${ext}'
+import type {
+  RouteConfig,
+  QueryBuilderConfig,
+  WriteStrategy,
+  FindManyPaginatedMode,
+  PaginationConfig,
+} from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
@@ -79,6 +90,7 @@ import {
   runSingleResultSSE,
   emitTerminalSSEError,
   removeReqCloseListener,
+  mergePaginationConfig,
   mapError,
   HttpError,
 } from '../operationRuntime${ext}'
@@ -88,6 +100,9 @@ import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
 const _env = getEnv()
 
+const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
+const FIND_MANY_PAGINATED_MODE: FindManyPaginatedMode = '${findManyPaginatedMode}'
+
 const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
 const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
 
@@ -95,6 +110,7 @@ type OperationConfigLike = {
   before?: RequestHandler[]
   after?: RequestHandler[]
   shape?: Record<string, unknown>
+  pagination?: Partial<PaginationConfig>
   progressive?: Record<string, ProgressiveVariantConfig>
   progressiveStages?: Record<string, ProgressiveStage<unknown>>
 }
@@ -107,7 +123,7 @@ type ExtendedRequest = Request & {
 
 type LocalsBag = {
   parsedQuery?: Record<string, unknown>
-  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
+  routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
   data?: unknown
@@ -154,7 +170,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         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' },
+        { format: 'json', writeStrategy: WRITE_STRATEGY },
       )
   const openApiYamlSpec = openApiDisabled
     ? null
@@ -163,7 +179,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         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' },
+        { format: 'yaml', writeStrategy: WRITE_STRATEGY },
       )
 
   const qbEnabled = isQueryBuilderEnabled(config)
@@ -190,6 +206,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
       guardShape: locals.guardShape,
       guardCaller: locals.guardCaller,
       paginationConfig: locals.routeConfig?.pagination,
+      findManyPaginatedMode: FIND_MANY_PAGINATED_MODE,
     }
   }
 
@@ -213,8 +230,9 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
   const setShape = (opConfig: OperationConfigLike): RequestHandler => {
     return (req, res, next) => {
       const locals = readLocals(res)
-      if (config.pagination) {
-        locals.routeConfig = { pagination: config.pagination }
+      const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
+      if (merged) {
+        locals.routeConfig = { pagination: merged }
       }
       const headerName = config.guard?.variantHeader || 'x-api-variant'
       const headerValue = req.get(headerName)

package/src/generators/generateRouterFastify.ts

@@ -2,17 +2,22 @@ import { DMMF } from '@prisma/generator-helper'
 import { generateRouteConfigType } from './generateRouteConfigType'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
+import { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export function generateFastifyRouterFunction({
   model,
   enums,
   guardShapesImport,
   importStyle,
+  writeStrategy,
+  findManyPaginatedMode,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
   guardShapesImport: string | null
   importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  findManyPaginatedMode: FindManyPaginatedMode
 }): string {
   const ext = importExt(importStyle)
   const modelName = model.name
@@ -64,15 +69,24 @@ import {
   ${modelName}Count,
   ${modelName}GroupBy,
 } from './${modelName}Handlers${ext}'
-import type { RouteConfig, FastifyHookHandler } from '../routeConfig.target${ext}'
+import type {
+  RouteConfig,
+  FastifyHookHandler,
+  WriteStrategy,
+  FindManyPaginatedMode,
+  PaginationConfig,
+} from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
-import { mapError, transformResult, HttpError, type OperationContext } from '../operationRuntime${ext}'
+import { mapError, transformResult, mergePaginationConfig, HttpError, type OperationContext } from '../operationRuntime${ext}'
 
 ${generateRouteConfigType(modelName, 'FastifyHookHandler', guardShapesImport, importStyle, 'fastify')}
 const _env = getEnv()
 
+const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
+const FIND_MANY_PAGINATED_MODE: FindManyPaginatedMode = '${findManyPaginatedMode}'
+
 const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
 
 const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
@@ -81,6 +95,7 @@ type OperationConfigLike = {
   before?: FastifyHookHandler[]
   after?: FastifyHookHandler[]
   shape?: Record<string, unknown>
+  pagination?: Partial<PaginationConfig>
 }
 
 type FastifyExtended = FastifyRequest & {
@@ -88,7 +103,7 @@ type FastifyExtended = FastifyRequest & {
   postgres?: unknown
   sqlite?: unknown
   parsedQuery?: Record<string, unknown>
-  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
+  routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
   resultData?: unknown
@@ -134,9 +149,9 @@ function makeShapeHook(
 ): (request: FastifyRequest) => void {
   return (request: FastifyRequest) => {
     const fx = request as FastifyExtended
-    const paginationConfig = (config as { pagination?: OperationContext['paginationConfig'] }).pagination
-    if (paginationConfig) {
-      fx.routeConfig = { pagination: paginationConfig }
+    const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
+    if (merged) {
+      fx.routeConfig = { pagination: merged }
     }
     const headerName = (config.guard?.variantHeader || 'x-api-variant').toLowerCase()
     const headerValue = request.headers[headerName]
@@ -203,7 +218,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' },
+        { format: 'json', writeStrategy: WRITE_STRATEGY },
       )
   const openApiYamlSpec = openApiDisabled
     ? null
@@ -212,7 +227,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' },
+        { format: 'yaml', writeStrategy: WRITE_STRATEGY },
       )
 
   const qbEnabled = isQueryBuilderEnabled(config)
@@ -228,6 +243,10 @@ export async function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(
     }
   }
 
+  fastify.addHook('onRequest', async (request: FastifyRequest) => {
+    (request as FastifyExtended & { findManyPaginatedMode?: FindManyPaginatedMode }).findManyPaginatedMode = FIND_MANY_PAGINATED_MODE
+  })
+
   fastify.setErrorHandler((error: FastifyError, _request: FastifyRequest, reply: FastifyReply) => {
     const e = error as { status?: number; statusCode?: number; message?: string }
     const status = e.status ?? e.statusCode ?? 500

package/src/generators/generateRouterHono.ts

@@ -2,17 +2,22 @@ import { DMMF } from '@prisma/generator-helper'
 import { generateRouteConfigType } from './generateRouteConfigType'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
+import { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export function generateHonoRouterFunction({
   model,
   enums,
   guardShapesImport,
   importStyle,
+  writeStrategy,
+  findManyPaginatedMode,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
   guardShapesImport: string | null
   importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  findManyPaginatedMode: FindManyPaginatedMode
 }): string {
   const ext = importExt(importStyle)
   const modelName = model.name
@@ -73,15 +78,26 @@ import type {
   HonoEnvBase,
   HonoInternalVariables,
   GeneratedHonoEnv,
+  WriteStrategy,
+  FindManyPaginatedMode,
+  PaginationConfig,
 } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
-import { mapError, transformResult, type OperationContext } from '../operationRuntime${ext}'
+import {
+  mapError,
+  transformResult,
+  mergePaginationConfig,
+  type OperationContext,
+} from '../operationRuntime${ext}'
 
 ${generateRouteConfigType(modelName, 'HonoHookHandler', guardShapesImport, importStyle, 'hono')}
 const _env = getEnv()
 
+const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
+const FIND_MANY_PAGINATED_MODE: FindManyPaginatedMode = '${findManyPaginatedMode}'
+
 const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
 
 const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
@@ -90,6 +106,7 @@ type OperationConfigLike<TEnv extends HonoEnvBase> = {
   before?: HonoHookHandler<TEnv>[]
   after?: HonoHookHandler<TEnv>[]
   shape?: Record<string, unknown>
+  pagination?: Partial<PaginationConfig>
 }
 
 const defaultOpConfig = Object.freeze({
@@ -97,7 +114,7 @@ const defaultOpConfig = Object.freeze({
   after: Object.freeze([]),
 }) as unknown as OperationConfigLike<HonoEnvBase>
 
-type HandlerContext = Context<{ Variables: HonoInternalVariables }>
+type HandlerContext = Context<{ Variables: HonoInternalVariables & { findManyPaginatedMode?: FindManyPaginatedMode } }>
 
 function isQueryBuilderEnabled(config: RouteConfig): boolean {
   if (config.queryBuilder === false) return false
@@ -150,10 +167,11 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
   opConfig: OperationConfigLike<TEnv>,
 ) {
   return (c: Context<GeneratedHonoEnv<TEnv>>): void => {
-    const paginationConfig = (config as { pagination?: OperationContext['paginationConfig'] }).pagination
-    if (paginationConfig) {
-      c.set('routeConfig', { pagination: paginationConfig })
+    const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
+    if (merged) {
+      c.set('routeConfig', { pagination: merged })
     }
+    ;(c as unknown as HandlerContext).set('findManyPaginatedMode', FIND_MANY_PAGINATED_MODE)
     const headerName = config.guard?.variantHeader || 'x-api-variant'
     const headerValue = c.req.header(headerName)
     const caller = config.guard?.resolveVariant?.(c) ?? headerValue ?? undefined
@@ -224,7 +242,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' },
+        { format: 'json', writeStrategy: WRITE_STRATEGY },
       )
   const openApiYamlSpec = openApiDisabled
     ? null
@@ -233,7 +251,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' },
+        { format: 'yaml', writeStrategy: WRITE_STRATEGY },
       )
 
   if (isQueryBuilderEnabled(config as RouteConfig)) {
@@ -270,17 +288,17 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
     parseFn: (c: HandlerContext) => Promise<void>,
   ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
     try {
-      await parseFn(c)
+      await parseFn(c as unknown as HandlerContext)
       makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig)(c)
       const { before = [], after = [] } = opConfig
       const beforeResp = await runHooks<TEnv>(before, c)
       if (beforeResp) return beforeResp
-      await handlerFn(c)
+      await handlerFn(c as unknown as HandlerContext)
       const afterResp = await runHooks<TEnv>(after, c)
       if (afterResp) return afterResp
-      return sendResult(c)
+      return sendResult(c as unknown as HandlerContext)
     } catch (error: unknown) {
-      return sendError(c, error)
+      return sendError(c as unknown as HandlerContext, error)
     }
   }
 
@@ -289,17 +307,17 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
     handlerFn: (c: HandlerContext) => Promise<void>,
   ) => async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
     try {
-      await parseWriteBodyMiddleware(c)
+      await parseWriteBodyMiddleware(c as unknown as HandlerContext)
       makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig)(c)
       const { before = [], after = [] } = opConfig
       const beforeResp = await runHooks<TEnv>(before, c)
       if (beforeResp) return beforeResp
-      await handlerFn(c)
+      await handlerFn(c as unknown as HandlerContext)
       const afterResp = await runHooks<TEnv>(after, c)
       if (afterResp) return afterResp
-      return sendResult(c)
+      return sendResult(c as unknown as HandlerContext)
     } catch (error: unknown) {
-      return sendError(c, error)
+      return sendError(c as unknown as HandlerContext, error)
     }
   }