prisma-generator-express 1.56.4 → 1.58.0

package/src/generators/generateRouterHono.ts

@@ -11,6 +11,7 @@ export function generateHonoRouterFunction({
   importStyle,
   writeStrategy,
   findManyPaginatedMode,
+  dropGuard,
 }: {
   model: DMMF.Model
   enums: DMMF.DatamodelEnum[]
@@ -18,6 +19,7 @@ export function generateHonoRouterFunction({
   importStyle: ImportStyle
   writeStrategy: WriteStrategy
   findManyPaginatedMode: FindManyPaginatedMode
+  dropGuard: boolean
 }): string {
   const ext = importExt(importStyle)
   const modelName = model.name
@@ -48,10 +50,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,
@@ -71,40 +72,41 @@ 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'
 
 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>
 }
@@ -114,20 +116,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>
@@ -159,7 +148,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>(
@@ -171,37 +173,34 @@ 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
     if (caller) c.set('guardCaller', caller)
-    if (opConfig.shape) {
+    if (opConfig.shape && !DROP_GUARD) {
       c.set('guardShape', opConfig.shape)
     }
   }
 }
 
-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
 }
@@ -216,69 +215,81 @@ function sendResult(c: HandlerContext): Response {
 }
 
 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 Record<string, unknown>))
     app.get(openapiYamlPath, (c) => {
       c.header('Content-Type', 'application/yaml')
-      return c.body(openApiYamlSpec as string)
+      return c.body(getOpenApiYaml())
     })
   }
 
@@ -291,10 +302,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) {
@@ -310,10 +321,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) {
@@ -326,55 +337,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))
@@ -384,52 +395,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(
@@ -79,6 +79,17 @@ function getFindManyPaginatedMode(
   )
 }
 
+function getDropGuard(options: GeneratorOptions): boolean {
+  const raw = (options.generator.config as Record<string, unknown>).dropGuard
+  if (raw === undefined || raw === null || raw === '') return false
+  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".`,
+  )
+}
+
 function validateClientGeneratorPresent(options: GeneratorOptions): void {
   getRelativeClientPath(
     options,
@@ -90,7 +101,7 @@ generatorHandler({
   onManifest() {
     return {
       version: require('../package.json').version,
-      defaultOutput: '../generated/express',
+      defaultOutput: '../generated/output',
       prettyName: GENERATOR_NAME,
     }
   },
@@ -99,12 +110,13 @@ generatorHandler({
     const target = getTarget(options)
     const writeStrategy = getWriteStrategy(options)
     const findManyPaginatedMode = getFindManyPaginatedMode(options)
+    const dropGuard = getDropGuard(options)
 
     const manifestDefaultAbs = path.resolve(
       __dirname,
       '..',
       'generated',
-      target,
+      'output',
     )
     const currentOutput = options.generator.output?.value
     const isUnsetOrManifestDefault =
@@ -124,6 +136,9 @@ generatorHandler({
     console.log(`  Import style: ${importStyle}`)
     console.log(`  Write strategy: ${writeStrategy}`)
     console.log(`  findManyPaginated mode: ${findManyPaginatedMode}`)
+    console.log(
+      `  Drop guard (generator): ${dropGuard}${dropGuard ? '' : ' (runtime E2E=true will also drop guard)'}`,
+    )
 
     if (options.dmmf.datamodel.models.length > 0) {
       validateClientGeneratorPresent(options)
@@ -151,7 +166,9 @@ generatorHandler({
       }
       modelNames.push(model.name)
 
-      const guardShapesImport = getGuardShapesImport(options, model.name)
+      const guardShapesImport = dropGuard
+        ? null
+        : getGuardShapesImport(options, model.name)
 
       await writeFileSafely({
         content: generateModelCore({
@@ -181,6 +198,7 @@ generatorHandler({
               importStyle,
               writeStrategy,
               findManyPaginatedMode,
+              dropGuard,
             })
           : target === 'hono'
             ? generateHonoRouterFunction({
@@ -190,6 +208,7 @@ generatorHandler({
                 importStyle,
                 writeStrategy,
                 findManyPaginatedMode,
+                dropGuard,
               })
             : generateRouterFunction({
                 model: model as DMMF.Model,
@@ -198,6 +217,7 @@ generatorHandler({
                 importStyle,
                 writeStrategy,
                 findManyPaginatedMode,
+                dropGuard,
               })
 
       await writeFileSafely({
@@ -258,4 +278,4 @@ generatorHandler({
     console.log(`✓ ${modelNames.length} models (${target})`)
     console.log('')
   },
-})
+})