prisma-generator-express 1.57.0 → 1.58.1

package/src/generators/generateRouterHono.ts

@@ -2,7 +2,7 @@ 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'
+import { WriteStrategy } from '../constants'
 
 export function generateHonoRouterFunction({
   model,
@@ -10,7 +10,6 @@ export function generateHonoRouterFunction({
   guardShapesImport,
   importStyle,
   writeStrategy,
-  findManyPaginatedMode,
   dropGuard,
 }: {
   model: DMMF.Model
@@ -18,7 +17,6 @@ export function generateHonoRouterFunction({
   guardShapesImport: string | null
   importStyle: ImportStyle
   writeStrategy: WriteStrategy
-  findManyPaginatedMode: FindManyPaginatedMode
   dropGuard: boolean
 }): string {
   const ext = importExt(importStyle)
@@ -50,10 +48,9 @@ export function generateHonoRouterFunction({
     }))
 
   return `import { Hono } from 'hono'
-import type { Context, Next } from 'hono'
+import type { Context } from 'hono'
 import type { ContentfulStatusCode } from 'hono/utils/http-status'
 import { HTTPException } from 'hono/http-exception'
-import { startQueryBuilder } from '../queryBuilder${ext}'
 import {
   ${modelName}FindUnique,
   ${modelName}FindUniqueOrThrow,
@@ -73,41 +70,49 @@ import {
   ${modelName}Aggregate,
   ${modelName}Count,
   ${modelName}GroupBy,
+  ${modelName}UpdateEach,
 } from './${modelName}Handlers${ext}'
 import type {
   RouteConfig,
-  HonoHookHandler,
+  HonoBeforeHook,
+  HonoAfterHook,
   HonoEnvBase,
   HonoInternalVariables,
   GeneratedHonoEnv,
   WriteStrategy,
-  FindManyPaginatedMode,
   PaginationConfig,
 } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
-import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
+import { normalizePrefix, getEnv, sanitizeKeys } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
+import { validateCountSourceWhere } from '../routeConfig${ext}'
 import {
   mapError,
   transformResult,
   mergePaginationConfig,
-  type OperationContext,
 } from '../operationRuntime${ext}'
 
-${generateRouteConfigType(modelName, 'HonoHookHandler', guardShapesImport, importStyle, 'hono')}
+${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono')}
 const _env = getEnv()
 
 const WRITE_STRATEGY: WriteStrategy = '${writeStrategy}'
-const FIND_MANY_PAGINATED_MODE: FindManyPaginatedMode = '${findManyPaginatedMode}'
 const DROP_GUARD = ${dropGuard} || _env.E2E === 'true'
 
+type JsonLike =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonLike[]
+  | { [k: string]: JsonLike }
+
 const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
 
 const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
 
 type OperationConfigLike<TEnv extends HonoEnvBase> = {
-  before?: HonoHookHandler<TEnv>[]
-  after?: HonoHookHandler<TEnv>[]
+  before?: HonoBeforeHook<TEnv>[]
+  after?: HonoAfterHook<TEnv>[]
   shape?: Record<string, unknown>
   pagination?: Partial<PaginationConfig>
 }
@@ -117,20 +122,7 @@ const defaultOpConfig = Object.freeze({
   after: Object.freeze([]),
 }) as unknown as OperationConfigLike<HonoEnvBase>
 
-type HandlerContext = Context<{ Variables: HonoInternalVariables & { findManyPaginatedMode?: FindManyPaginatedMode } }>
-
-function isQueryBuilderEnabled(config: RouteConfig): 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) {
-  if (config.queryBuilder === false) return null
-  if (typeof config.queryBuilder === 'object') return config.queryBuilder
-  return {}
-}
+type HandlerContext = Context<{ Variables: HonoInternalVariables }>
 
 async function parseQueryMiddleware(c: HandlerContext): Promise<void> {
   const raw = c.req.query() as Record<string, unknown>
@@ -162,7 +154,20 @@ async function parseWriteBodyMiddleware(c: HandlerContext): Promise<void> {
   if (!body || typeof body !== 'object' || Array.isArray(body)) {
     throw new HTTPException(400, { message: 'Request body must be a JSON object' })
   }
-  c.set('body', sanitizeKeys(body as Record<string, unknown>))
+  c.set('body', body)
+}
+
+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)
 }
 
 function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
@@ -174,7 +179,6 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
     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
@@ -185,26 +189,24 @@ function makeShapeMiddleware<TCtx, TPrisma, TEnv extends HonoEnvBase>(
   }
 }
 
-async function runHooks<TEnv extends HonoEnvBase>(
-  hooks: HonoHookHandler<TEnv>[],
+async function runBeforeHooks<TEnv extends HonoEnvBase>(
+  hooks: HonoBeforeHook<TEnv>[],
   c: Context<GeneratedHonoEnv<TEnv>>,
 ): Promise<Response | undefined> {
   for (const hook of hooks) {
-    let advanced = false
-    const next: Next = async () => {
-      advanced = true
-    }
-    const result = await hook(c, next)
+    const result = await hook(c)
+    if (result instanceof Response) return result
+  }
+  return undefined
+}
+
+async function runAfterHooks<TEnv extends HonoEnvBase>(
+  hooks: 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
-    if (!advanced) {
-      if (_env.NODE_ENV !== 'production') {
-        console.warn(
-          '[hono-router] Hook returned without calling next() or returning a Response. ' +
-          'Use \`return c.json(...)\` to short-circuit, or \`await next()\` to continue.',
-        )
-      }
-      return c.body(null) ?? undefined
-    }
   }
   return undefined
 }
@@ -215,73 +217,85 @@ function sendResult(c: HandlerContext): Response {
   if (data === undefined) {
     throw new HTTPException(500, { message: 'No data set by handler' })
   }
-  return c.json(transformResult(data) as Record<string, unknown>, status as ContentfulStatusCode)
+  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>> {
+  validateCountSourceWhere(config.pagination?.countSource, '${modelName} pagination')
+  validateCountSourceWhere(
+    (config.findManyPaginated && typeof config.findManyPaginated === 'object' ? config.findManyPaginated : undefined)?.pagination?.countSource,
+    '${modelName} findManyPaginated pagination',
+  )
+
   const app = new Hono<GeneratedHonoEnv<TEnv>>()
 
+  const isEnabled = (value: unknown): boolean => value !== false && !!(config.enableAll || value)
+
   const customPrefix = normalizePrefix(config.customUrlPrefix || '')
   const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
   const basePath = customPrefix + modelPrefix
 
   const openApiDisabled = config.disableOpenApi === true
     || (config.disableOpenApi !== false && (
-      _env.DISABLE_OPENAPI === 'true'
-      || _env.NODE_ENV === 'production'
+      _env.NODE_ENV === 'production'
+      || _env.DISABLE_OPENAPI === 'true'
     ))
 
   const postReadsEnabled = !config.disablePostReads
 
-  const openApiJsonSpec = openApiDisabled
-    ? null
-    : buildModelOpenApi(
+  let _openApiJsonCache: unknown = undefined
+  const getOpenApiJson = (): unknown => {
+    if (_openApiJsonCache === undefined) {
+      _openApiJsonCache = buildModelOpenApi(
         '${modelName}',
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as RouteConfig,
         { format: 'json', writeStrategy: WRITE_STRATEGY },
       )
-  const openApiYamlSpec = openApiDisabled
-    ? null
-    : buildModelOpenApi(
+    }
+    return _openApiJsonCache
+  }
+  let _openApiYamlCache: string | undefined = undefined
+  const getOpenApiYaml = (): string => {
+    if (_openApiYamlCache === undefined) {
+      _openApiYamlCache = buildModelOpenApi(
         '${modelName}',
         MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
         MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
         config as RouteConfig,
         { format: 'yaml', writeStrategy: WRITE_STRATEGY },
-      )
-
-  if (isQueryBuilderEnabled(config as RouteConfig)) {
-    const qbConfig = getQueryBuilderConfig(config as RouteConfig)
-    if (qbConfig) {
-      try {
-        startQueryBuilder(qbConfig)
-      } catch (err) {
-        if (_env.NODE_ENV !== 'production') console.warn('[query-builder]', err)
-      }
+      ) as string
     }
+    return _openApiYamlCache
+  }
+
+  if (config.queryBuilder && config.queryBuilder !== false && _env.NODE_ENV !== 'production') {
+    console.warn(
+      '[${modelName}Router] queryBuilder config is present but Hono target does not auto-start it. ' +
+      'Run \`npx prisma-query-builder-ui\` in a separate process.',
+    )
   }
 
   app.onError((err, c) => {
-    if (err instanceof HTTPException) {
-      return c.json({ message: err.message }, err.status as ContentfulStatusCode)
-    }
     return sendError(c as HandlerContext, err)
   })
 
   if (!openApiDisabled) {
     const openapiJsonPath = basePath ? \`\${basePath}/openapi.json\` : '/openapi.json'
     const openapiYamlPath = basePath ? \`\${basePath}/openapi.yaml\` : '/openapi.yaml'
-    app.get(openapiJsonPath, (c) => c.json(openApiJsonSpec as Record<string, unknown>))
+    app.get(openapiJsonPath, (c) => c.json(getOpenApiJson() as JsonLike))
     app.get(openapiYamlPath, (c) => {
       c.header('Content-Type', 'application/yaml')
-      return c.body(openApiYamlSpec as string)
+      return c.body(getOpenApiYaml())
     })
   }
 
@@ -294,10 +308,10 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       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)
+      const beforeResp = await runBeforeHooks<TEnv>(before, c)
       if (beforeResp) return beforeResp
       await handlerFn(c as unknown as HandlerContext)
-      const afterResp = await runHooks<TEnv>(after, c)
+      const afterResp = await runAfterHooks<TEnv>(after, c)
       if (afterResp) return afterResp
       return sendResult(c as unknown as HandlerContext)
     } catch (error: unknown) {
@@ -313,10 +327,10 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       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)
+      const beforeResp = await runBeforeHooks<TEnv>(before, c)
       if (beforeResp) return beforeResp
       await handlerFn(c as unknown as HandlerContext)
-      const afterResp = await runHooks<TEnv>(after, c)
+      const afterResp = await runAfterHooks<TEnv>(after, c)
       if (afterResp) return afterResp
       return sendResult(c as unknown as HandlerContext)
     } catch (error: unknown) {
@@ -329,55 +343,55 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
       ?? (defaultOpConfig as OperationConfigLike<TEnv>)
   }
 
-  if (config.enableAll || config.findFirst) {
+  if (isEnabled(config.findFirst)) {
     const opConfig = opFor('findFirst')
     const path = basePath ? \`\${basePath}/first\` : '/first'
     app.get(path, handleRead(opConfig, ${modelName}FindFirst, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindFirst, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.findFirstOrThrow) {
+  if (isEnabled(config.findFirstOrThrow)) {
     const opConfig = opFor('findFirstOrThrow')
     const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
     app.get(path, handleRead(opConfig, ${modelName}FindFirstOrThrow, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindFirstOrThrow, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.findManyPaginated) {
+  if (isEnabled(config.findManyPaginated)) {
     const opConfig = opFor('findManyPaginated')
     const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
     app.get(path, handleRead(opConfig, ${modelName}FindManyPaginated, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindManyPaginated, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.aggregate) {
+  if (isEnabled(config.aggregate)) {
     const opConfig = opFor('aggregate')
     const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
     app.get(path, handleRead(opConfig, ${modelName}Aggregate, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}Aggregate, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.count) {
+  if (isEnabled(config.count)) {
     const opConfig = opFor('count')
     const path = basePath ? \`\${basePath}/count\` : '/count'
     app.get(path, handleRead(opConfig, ${modelName}Count, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}Count, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.groupBy) {
+  if (isEnabled(config.groupBy)) {
     const opConfig = opFor('groupBy')
     const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
     app.get(path, handleRead(opConfig, ${modelName}GroupBy, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}GroupBy, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.findUniqueOrThrow) {
+  if (isEnabled(config.findUniqueOrThrow)) {
     const opConfig = opFor('findUniqueOrThrow')
     const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
     app.get(path, handleRead(opConfig, ${modelName}FindUniqueOrThrow, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindUniqueOrThrow, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.findUnique) {
+  if (isEnabled(config.findUnique)) {
     const opConfig = opFor('findUnique')
     const path = basePath ? \`\${basePath}/unique\` : '/unique'
     app.get(path, handleRead(opConfig, ${modelName}FindUnique, parseQueryMiddleware))
     if (postReadsEnabled) app.post(path, handleRead(opConfig, ${modelName}FindUnique, parseBodyAsQueryMiddleware))
   }
-  if (config.enableAll || config.findMany) {
+  if (isEnabled(config.findMany)) {
     const opConfig = opFor('findMany')
     const path = basePath || '/'
     app.get(path, handleRead(opConfig, ${modelName}FindMany, parseQueryMiddleware))
@@ -387,52 +401,78 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any, TEnv extend
     }
   }
 
-  if (config.enableAll || config.createManyAndReturn) {
+  if (isEnabled(config.createManyAndReturn)) {
     const opConfig = opFor('createManyAndReturn')
     const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
     app.post(path, handleWrite(opConfig, ${modelName}CreateManyAndReturn))
   }
-  if (config.enableAll || config.createMany) {
+  if (isEnabled(config.createMany)) {
     const opConfig = opFor('createMany')
     const path = basePath ? \`\${basePath}/many\` : '/many'
     app.post(path, handleWrite(opConfig, ${modelName}CreateMany))
   }
-  if (config.enableAll || config.create) {
+  if (isEnabled(config.create)) {
     const opConfig = opFor('create')
     const path = basePath || '/'
     app.post(path, handleWrite(opConfig, ${modelName}Create))
   }
-  if (config.enableAll || config.updateManyAndReturn) {
+  if (isEnabled(config.updateManyAndReturn)) {
     const opConfig = opFor('updateManyAndReturn')
     const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
     app.put(path, handleWrite(opConfig, ${modelName}UpdateManyAndReturn))
   }
-  if (config.enableAll || config.updateMany) {
+  if (isEnabled(config.updateMany)) {
     const opConfig = opFor('updateMany')
     const path = basePath ? \`\${basePath}/many\` : '/many'
     app.put(path, handleWrite(opConfig, ${modelName}UpdateMany))
   }
-  if (config.enableAll || config.update) {
+  if (isEnabled(config.update)) {
     const opConfig = opFor('update')
     const path = basePath || '/'
     app.put(path, handleWrite(opConfig, ${modelName}Update))
   }
-  if (config.enableAll || config.upsert) {
+  if (isEnabled(config.upsert)) {
     const opConfig = opFor('upsert')
     const path = basePath || '/'
     app.patch(path, handleWrite(opConfig, ${modelName}Upsert))
   }
-  if (config.enableAll || config.deleteMany) {
+  if (isEnabled(config.deleteMany)) {
     const opConfig = opFor('deleteMany')
     const path = basePath ? \`\${basePath}/many\` : '/many'
     app.delete(path, handleWrite(opConfig, ${modelName}DeleteMany))
   }
-  if (config.enableAll || config.delete) {
+  if (isEnabled(config.delete)) {
     const opConfig = opFor('delete')
     const path = basePath || '/'
     app.delete(path, handleWrite(opConfig, ${modelName}Delete))
   }
 
+  if (config.updateEach) {
+    const opConfig = (config.updateEach as unknown as OperationConfigLike<TEnv> | undefined) ?? (defaultOpConfig as OperationConfigLike<TEnv>)
+    if ((!opConfig.before || opConfig.before.length === 0) && _env.NODE_ENV !== 'production') {
+      console.warn(
+        '[${modelName}Router] updateEach is enabled without a before hook. ' +
+        'This endpoint bypasses guard shapes and should be protected by authentication middleware.',
+      )
+    }
+    const path = basePath ? \`\${basePath}/each\` : '/each'
+    app.post(path, async (c: Context<GeneratedHonoEnv<TEnv>>): Promise<Response> => {
+      try {
+        await parseUpdateEachBodyMiddleware(c as unknown as HandlerContext)
+        makeShapeMiddleware<TCtx, TPrisma, TEnv>(config, opConfig)(c)
+        const { before = [], after = [] } = opConfig
+        const beforeResp = await runBeforeHooks<TEnv>(before, c)
+        if (beforeResp) return beforeResp
+        await ${modelName}UpdateEach(c as unknown as HandlerContext)
+        const afterResp = await runAfterHooks<TEnv>(after, c)
+        if (afterResp) return afterResp
+        return sendResult(c as unknown as HandlerContext)
+      } catch (error: unknown) {
+        return sendError(c as unknown as HandlerContext, error)
+      }
+    })
+  }
+
   return app
 }
 `

package/src/index.ts

@@ -32,7 +32,7 @@ import {
   FindManyPaginatedMode,
 } from './constants'
 
-const GENERATOR_OFF_RE = /\bgenerator off\b/
+const GENERATOR_OFF_RE = /^\s*generator off\s*$/m
 
 function getTarget(options: GeneratorOptions): Target {
   const raw = String(
@@ -85,9 +85,12 @@ function getDropGuard(options: GeneratorOptions): boolean {
   const lower = String(raw).toLowerCase()
   if (lower === 'true' || lower === '1') return true
   if (lower === 'false' || lower === '0') return false
-  throw new Error(
-    `Invalid dropGuard "${raw}". Expected "true" or "false".`,
+  console.warn(
+    `[prisma-generator-express] dropGuard="${raw}" is not a recognized boolean value. ` +
+      `Treating as false. Expected "true", "false", "1", "0", or "" (unset). ` +
+      `If you used env("VAR_NAME"), set VAR_NAME to "true" or "false".`,
   )
+  return false
 }
 
 function validateClientGeneratorPresent(options: GeneratorOptions): void {
@@ -101,7 +104,7 @@ generatorHandler({
   onManifest() {
     return {
       version: require('../package.json').version,
-      defaultOutput: '../generated/express',
+      defaultOutput: '../generated/output',
       prettyName: GENERATOR_NAME,
     }
   },
@@ -116,7 +119,7 @@ generatorHandler({
       __dirname,
       '..',
       'generated',
-      target,
+      'output',
     )
     const currentOutput = options.generator.output?.value
     const isUnsetOrManifestDefault =
@@ -136,7 +139,9 @@ generatorHandler({
     console.log(`  Import style: ${importStyle}`)
     console.log(`  Write strategy: ${writeStrategy}`)
     console.log(`  findManyPaginated mode: ${findManyPaginatedMode}`)
-    console.log(`  Drop guard: ${dropGuard}`)
+    console.log(
+      `  Drop guard (generator): ${dropGuard}${dropGuard ? '' : ' (runtime E2E=true will also drop guard)'}`,
+    )
 
     if (options.dmmf.datamodel.models.length > 0) {
       validateClientGeneratorPresent(options)
@@ -205,7 +210,6 @@ generatorHandler({
                 guardShapesImport,
                 importStyle,
                 writeStrategy,
-                findManyPaginatedMode,
                 dropGuard,
               })
             : generateRouterFunction({